Auto-merge upstream openclaw/openclaw

Author: github-actions[bot]

CHANGELOG.md

@@ -117,6 +117,9 @@ Docs: https://docs.openclaw.ai
 - CLI/Commander: preserve Commander-computed exit codes for argument and help-error paths, and cover the user-argv parse mode in the regression tests so invalid CLI invocations no longer report success when exits are intercepted. (#60923) Thanks @Linux2010.
 - Telegram/native command menu: trim long menu descriptions before dropping commands so sub-100 command sets can still fit Telegram's payload budget and keep more `/` entries visible. (#61129) Thanks @neeravmakwana.
 - Agents/Claude CLI: keep non-interactive `--permission-mode bypassPermissions` when custom `cliBackends.claude-cli.args` override defaults, so cron and heartbeat Claude CLI runs do not regress to interactive approval mode. (#61114) Thanks @cathrynlavery and @thewilloftheshadow.
+- Agents/skills: skip `.git` and `node_modules` when mirroring skills into sandbox workspaces so read-only sandboxes do not copy repo history or dependency trees. (#61090) Thanks @joelnishanth.
+- Android/Talk Mode: cancel in-flight `talk.speak` playback when speech is explicitly stopped, so stale replies stop starting after barge-in or manual stop. (#61164) Thanks @obviyus.
+- Plugins/onboarding: write dotted plugin uiHint paths like Brave `webSearch.mode` as nested plugin config so `llm-context` setup stops failing validation. (#61159) Thanks @obviyus.
 
 ## 2026.4.2
 

apps/android/app/src/main/java/ai/openclaw/app/voice/TalkModeManager.kt

@@ -266,7 +266,6 @@ class TalkModeManager(
     if (playbackEnabled == enabled) return
     playbackEnabled = enabled
     if (!enabled) {
-      playbackGeneration.incrementAndGet()
       stopSpeaking()
     }
   }
@@ -742,6 +741,7 @@ class TalkModeManager(
         ttsJob
       }
     activeJob?.cancel()
+    talkAudioPlayer.stop()
     stopTextToSpeechPlayback()
   }
 
@@ -829,17 +829,16 @@ class TalkModeManager(
   }
 
   private fun stopSpeaking(resetInterrupt: Boolean = true) {
+    playbackGeneration.incrementAndGet()
     if (!_isSpeaking.value) {
-      talkAudioPlayer.stop()
-      stopTextToSpeechPlayback()
+      cancelActivePlayback()
       abandonAudioFocus()
       return
     }
     if (resetInterrupt) {
       lastInterruptedAtSeconds = null
     }
-    talkAudioPlayer.stop()
-    stopTextToSpeechPlayback()
+    cancelActivePlayback()
     _isSpeaking.value = false
     abandonAudioFocus()
   }

apps/android/app/src/test/java/ai/openclaw/app/voice/TalkModeManagerTest.kt

@@ -0,0 +1,97 @@
+package ai.openclaw.app.voice
+
+import ai.openclaw.app.gateway.DeviceAuthEntry
+import ai.openclaw.app.gateway.DeviceAuthTokenStore
+import ai.openclaw.app.gateway.DeviceIdentityStore
+import ai.openclaw.app.gateway.GatewaySession
+import java.util.concurrent.atomic.AtomicLong
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class TalkModeManagerTest {
+  @Test
+  fun stopTtsCancelsTrackedPlaybackJob() {
+    val manager = createManager()
+    val playbackJob = Job()
+
+    setPrivateField(manager, "ttsJob", playbackJob)
+    playbackGeneration(manager).set(7L)
+
+    manager.stopTts()
+
+    assertTrue(playbackJob.isCancelled)
+    assertEquals(8L, playbackGeneration(manager).get())
+  }
+
+  @Test
+  fun disablingPlaybackCancelsTrackedJobOnce() {
+    val manager = createManager()
+    val playbackJob = Job()
+
+    setPrivateField(manager, "ttsJob", playbackJob)
+    playbackGeneration(manager).set(11L)
+
+    manager.setPlaybackEnabled(false)
+    manager.setPlaybackEnabled(false)
+
+    assertTrue(playbackJob.isCancelled)
+    assertEquals(12L, playbackGeneration(manager).get())
+  }
+
+  private fun createManager(): TalkModeManager {
+    val app = RuntimeEnvironment.getApplication()
+    val sessionJob = SupervisorJob()
+    val session =
+      GatewaySession(
+        scope = CoroutineScope(sessionJob + Dispatchers.Default),
+        identityStore = DeviceIdentityStore(app),
+        deviceAuthStore = InMemoryDeviceAuthStore(),
+        onConnected = { _, _, _ -> },
+        onDisconnected = {},
+        onEvent = { _, _ -> },
+      )
+    return TalkModeManager(
+      context = app,
+      scope = CoroutineScope(SupervisorJob() + Dispatchers.Default),
+      session = session,
+      supportsChatSubscribe = false,
+      isConnected = { true },
+    )
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  private fun playbackGeneration(manager: TalkModeManager): AtomicLong {
+    return readPrivateField(manager, "playbackGeneration") as AtomicLong
+  }
+
+  private fun setPrivateField(target: Any, name: String, value: Any?) {
+    val field = target.javaClass.getDeclaredField(name)
+    field.isAccessible = true
+    field.set(target, value)
+  }
+
+  private fun readPrivateField(target: Any, name: String): Any? {
+    val field = target.javaClass.getDeclaredField(name)
+    field.isAccessible = true
+    return field.get(target)
+  }
+}
+
+private class InMemoryDeviceAuthStore : DeviceAuthTokenStore {
+  override fun loadEntry(deviceId: String, role: String): DeviceAuthEntry? = null
+
+  override fun saveToken(deviceId: String, role: String, token: String, scopes: List<String>) = Unit
+
+  override fun clearToken(deviceId: String, role: String) = Unit
+}

extensions/discord/src/doctor-contract.ts

@@ -11,6 +11,98 @@ function asObjectRecord(value: unknown): Record<string, unknown> | null {
     : null;
 }
 
+function normalizeDiscordDmAliases(params: {
+  entry: Record<string, unknown>;
+  pathPrefix: string;
+  changes: string[];
+}): { entry: Record<string, unknown>; changed: boolean } {
+  let changed = false;
+  let updated: Record<string, unknown> = params.entry;
+  const rawDm = updated.dm;
+  const dm = asObjectRecord(rawDm) ? (structuredClone(rawDm) as Record<string, unknown>) : null;
+  let dmChanged = false;
+  const shouldPromoteLegacyAllowFrom = !(
+    params.pathPrefix === "channels.discord" && asObjectRecord(updated.accounts)
+  );
+
+  const allowFromEqual = (a: unknown, b: unknown): boolean => {
+    if (!Array.isArray(a) || !Array.isArray(b)) {
+      return false;
+    }
+    const na = a.map((v) => String(v).trim()).filter(Boolean);
+    const nb = b.map((v) => String(v).trim()).filter(Boolean);
+    if (na.length !== nb.length) {
+      return false;
+    }
+    return na.every((v, i) => v === nb[i]);
+  };
+
+  const topDmPolicy = updated.dmPolicy;
+  const legacyDmPolicy = dm?.policy;
+  if (topDmPolicy === undefined && legacyDmPolicy !== undefined) {
+    updated = { ...updated, dmPolicy: legacyDmPolicy };
+    changed = true;
+    if (dm) {
+      delete dm.policy;
+      dmChanged = true;
+    }
+    params.changes.push(`Moved ${params.pathPrefix}.dm.policy → ${params.pathPrefix}.dmPolicy.`);
+  } else if (
+    topDmPolicy !== undefined &&
+    legacyDmPolicy !== undefined &&
+    topDmPolicy === legacyDmPolicy
+  ) {
+    if (dm) {
+      delete dm.policy;
+      dmChanged = true;
+      params.changes.push(`Removed ${params.pathPrefix}.dm.policy (dmPolicy already set).`);
+    }
+  }
+
+  const topAllowFrom = updated.allowFrom;
+  const legacyAllowFrom = dm?.allowFrom;
+  if (shouldPromoteLegacyAllowFrom) {
+    if (topAllowFrom === undefined && legacyAllowFrom !== undefined) {
+      updated = { ...updated, allowFrom: legacyAllowFrom };
+      changed = true;
+      if (dm) {
+        delete dm.allowFrom;
+        dmChanged = true;
+      }
+      params.changes.push(
+        `Moved ${params.pathPrefix}.dm.allowFrom → ${params.pathPrefix}.allowFrom.`,
+      );
+    } else if (
+      topAllowFrom !== undefined &&
+      legacyAllowFrom !== undefined &&
+      allowFromEqual(topAllowFrom, legacyAllowFrom)
+    ) {
+      if (dm) {
+        delete dm.allowFrom;
+        dmChanged = true;
+        params.changes.push(`Removed ${params.pathPrefix}.dm.allowFrom (allowFrom already set).`);
+      }
+    }
+  }
+
+  if (dm && asObjectRecord(rawDm) && dmChanged) {
+    const keys = Object.keys(dm);
+    if (keys.length === 0) {
+      if (updated.dm !== undefined) {
+        const { dm: _ignored, ...rest } = updated;
+        updated = rest;
+        changed = true;
+        params.changes.push(`Removed empty ${params.pathPrefix}.dm after migration.`);
+      }
+    } else {
+      updated = { ...updated, dm };
+      changed = true;
+    }
+  }
+
+  return { entry: updated, changed };
+}
+
 function normalizeDiscordStreamingAliases(params: {
   entry: Record<string, unknown>;
   pathPrefix: string;
@@ -219,6 +311,14 @@ export function normalizeCompatibilityConfig({
   let updated = rawEntry;
   let changed = false;
 
+  const dm = normalizeDiscordDmAliases({
+    entry: updated,
+    pathPrefix: "channels.discord",
+    changes,
+  });
+  updated = dm.entry;
+  changed = changed || dm.changed;
+
   const streaming = normalizeDiscordStreamingAliases({
     entry: updated,
     pathPrefix: "channels.discord",
@@ -236,16 +336,23 @@ export function normalizeCompatibilityConfig({
       if (!account) {
         continue;
       }
+      let accountEntry = account;
+      let accountChanged = false;
+      const accountDm = normalizeDiscordDmAliases({
+        entry: accountEntry,
+        pathPrefix: `channels.discord.accounts.${accountId}`,
+        changes,
+      });
+      accountEntry = accountDm.entry;
+      accountChanged = accountDm.changed;
       const accountStreaming = normalizeDiscordStreamingAliases({
-        entry: account,
+        entry: accountEntry,
         pathPrefix: `channels.discord.accounts.${accountId}`,
         changes,
       });
-      if (accountStreaming.changed) {
-        accounts[accountId] = accountStreaming.entry;
-        accountsChanged = true;
-      }
-      const accountVoice = asObjectRecord(accountStreaming.entry.voice);
+      accountEntry = accountStreaming.entry;
+      accountChanged = accountChanged || accountStreaming.changed;
+      const accountVoice = asObjectRecord(accountEntry.voice);
       if (
         accountVoice &&
         migrateLegacyTtsConfig(
@@ -254,10 +361,14 @@ export function normalizeCompatibilityConfig({
           changes,
         )
       ) {
-        accounts[accountId] = {
-          ...accountStreaming.entry,
+        accountEntry = {
+          ...accountEntry,
           voice: accountVoice,
         };
+        accountChanged = true;
+      }
+      if (accountChanged) {
+        accounts[accountId] = accountEntry;
         accountsChanged = true;
       }
     }

extensions/openrouter/index.test.ts

@@ -85,7 +85,9 @@ describe("openrouter provider hooks", () => {
     );
 
     expect(baseStreamFn).toHaveBeenCalledOnce();
-    expect(baseStreamFn.mock.calls[0]?.[0]).toMatchObject({
+    const firstCall = baseStreamFn.mock.calls[0];
+    const firstModel = firstCall?.[0];
+    expect(firstModel).toMatchObject({
       compat: {
         openRouterRouting: {
           order: ["moonshot"],

extensions/xai/stream.test.ts

@@ -10,7 +10,10 @@ import {
 type ToolPayload = {
   function?: Record<string, unknown>;
 };
-
+type XaiTestPayload = Record<string, unknown> & {
+  tools?: Array<{ type?: string; function?: Record<string, unknown> }>;
+  input?: unknown[];
+};
 function captureWrappedModelId(params: {
   modelId: string;
   fastMode: boolean;
@@ -63,10 +66,10 @@ describe("xai stream wrappers", () => {
 
   it("composes the xai provider stream chain from extra params", () => {
     let capturedModelId = "";
-    let capturedPayload: Record<string, unknown> | undefined;
+    let capturedPayload: XaiTestPayload | undefined;
     const baseStreamFn: StreamFn = (model, _context, options) => {
       capturedModelId = String(model.id);
-      const payload: Record<string, unknown> = {
+      const payload: XaiTestPayload = {
         reasoning: { effort: "high" },
         tools: [
           {

src/agents/model-selection.ts

@@ -6,7 +6,7 @@ import {
   toAgentModelListLike,
 } from "../config/model-input.js";
 import { createSubsystemLogger } from "../logging/subsystem.js";
-import { sanitizeForLog } from "../terminal/ansi.js";
+import { sanitizeForLog, stripAnsi } from "../terminal/ansi.js";
 import {
   resolveAgentConfig,
   resolveAgentEffectiveModelPrimary,
@@ -72,6 +72,22 @@ function normalizeAliasKey(value: string): string {
   return value.trim().toLowerCase();
 }
 
+function sanitizeModelWarningValue(value: string): string {
+  const stripped = value ? stripAnsi(value) : "";
+  let controlBoundary = -1;
+  for (let index = 0; index < stripped.length; index += 1) {
+    const code = stripped.charCodeAt(index);
+    if (code <= 0x1f || code === 0x7f) {
+      controlBoundary = index;
+      break;
+    }
+  }
+  if (controlBoundary === -1) {
+    return sanitizeForLog(stripped);
+  }
+  return sanitizeForLog(stripped.slice(0, controlBoundary));
+}
+
 export function modelKey(provider: string, model: string) {
   return sharedModelKey(provider, model);
 }
@@ -363,16 +379,8 @@ export function resolveConfiguredModelRef(params: {
         return aliasMatch.ref;
       }
 
-      const inferredProvider = inferUniqueProviderFromConfiguredModels({
-        cfg: params.cfg,
-        model: trimmed,
-      });
-      if (inferredProvider) {
-        return { provider: inferredProvider, model: trimmed };
-      }
-
       // Default to the configured provider if no provider is specified, but warn as this is deprecated.
-      const safeTrimmed = sanitizeForLog(trimmed);
+      const safeTrimmed = sanitizeModelWarningValue(trimmed);
       const safeResolved = sanitizeForLog(`${params.defaultProvider}/${safeTrimmed}`);
       getLog().warn(
         `Model "${safeTrimmed}" specified without provider. Falling back to "${safeResolved}". Please use "${safeResolved}" in your config.`,
@@ -404,7 +412,6 @@ export function resolveConfiguredModelRef(params: {
   const fallbackProvider = resolveConfiguredProviderFallback({
     cfg: params.cfg,
     defaultProvider: params.defaultProvider,
-    defaultModel: params.defaultModel,
   });
   if (fallbackProvider) {
     return fallbackProvider;