@ai-matrx/chat 0.6.6 → 0.7.1

package/dist/agents/redux/execution-system/thunks/dispatch-surface-write.thunk.js

@@ -1,42 +1,27 @@
 import { createAsyncThunk } from "@reduxjs/toolkit";
 import { extractErrorMessage } from "@ai-matrx/data/net";
-import { submitToolResult } from "../../../api/submit-tool-results.js";
+import { postDelegatedToolOutcome } from "./post-delegated-tool-outcome.js";
 import {
   applySurfaceWrite,
   readSurfaceWriteAddress
 } from "../../../../surfaces/runtime/surface-writeback.js";
 import { surfaceWriteToolOutput } from "../../../../surfaces/runtime/surface-write-tool-output.js";
 import { createSurfaceToolCall } from "./surface-tool-call.js";
-import { upsertToolLifecycle } from "../active-requests/active-requests.slice.js";
 import { setInstanceStatus } from "../conversations/conversations.slice.js";
 const dispatchSurfaceWrite = createAsyncThunk(
   "surfaceWriteback/dispatchAgentWrite",
   async ({ conversationId, requestId, callId, toolName, args }, { dispatch, getState }) => {
     const startedAt = performance.now();
     const finish = (output, errorMessage) => {
-      const durationMs = Math.round(performance.now() - startedAt);
-      dispatch(
-        upsertToolLifecycle({
-          requestId,
-          callId,
-          toolName,
-          status: errorMessage ? "error" : "completed",
-          isDelegated: true,
-          result: output,
-          ...errorMessage ? { errorType: "surface_write_failed", errorMessage } : {}
-        })
-      );
-      dispatch(
-        submitToolResult({
-          conversationId,
-          call_id: callId,
-          tool_name: toolName,
-          is_error: Boolean(errorMessage),
-          output,
-          duration_ms: durationMs,
-          ...errorMessage ? { error_message: errorMessage } : {}
-        })
-      );
+      postDelegatedToolOutcome(dispatch, {
+        conversationId,
+        requestId,
+        callId,
+        toolName,
+        output,
+        error: errorMessage ? { type: "surface_write_failed", message: errorMessage } : void 0,
+        durationMs: Math.round(performance.now() - startedAt)
+      });
     };
     const target = args.target;
     if (typeof target !== "string" || !target.trim()) {

package/dist/agents/redux/execution-system/thunks/execute-instance.thunk.js

@@ -11,6 +11,7 @@ import { mintClientTempId } from "@ai-matrx/kit/ids";
 import { createAsyncThunk } from "@reduxjs/toolkit";
 import { toast } from "../../../../host/notify.js";
 import { buildToolInjection } from "../utils/build-tool-injection.js";
+import { mergeHostTurnContext } from "../utils/host-turn.js";
 import { resolveRequestOverrides } from "../utils/request-overrides.js";
 import { attachOutputKindsFromState, attachSkillConfigFromState } from "../utils/build-skill-config-for-request.js";
 import { buildContinuationBody } from "../utils/continuation-body.js";
@@ -35,6 +36,7 @@ import {
   selectVariablesForRequest
 } from "../instance-variable-values/instance-variable-values.selectors.js";
 import { selectSettingsOverridesForApi } from "../instance-model-overrides/instance-model-overrides.selectors.js";
+import { collectAttachmentSourceContext } from "../../../../host/composer-extensions.js";
 import { selectInstanceContextEntries } from "../instance-context/instance-context.selectors.js";
 import {
   consumePerTurnContext,
@@ -465,6 +467,12 @@ const executeInstance = createAsyncThunk(
       if (injection.tools_replace)
         payload.tools_replace = injection.tools_replace;
       if (injection.client) payload.client = injection.client;
+      if (injection.hostContext) {
+        payload.context = mergeHostTurnContext(
+          payload.context,
+          injection.hostContext
+        );
+      }
       if (payload.target_instance_id && !injection.client?.state?.["desktop-native"]) {
         delete payload.target_instance_id;
       }
@@ -559,6 +567,18 @@ const executeInstance = createAsyncThunk(
           ...hostExtras.context
         };
       }
+      {
+        const sourceContext = await collectAttachmentSourceContext(
+          conversationId,
+          (sourceId, error) => console.warn(`[Matrx] Attachment source "${sourceId}" failed and was skipped:`, error)
+        );
+        if (sourceContext) {
+          routedPayload.context = {
+            ...routedPayload.context ?? {},
+            ...sourceContext
+          };
+        }
+      }
       {
         const { overrides, error } = resolveRequestOverrides(
           state,

package/dist/agents/redux/execution-system/thunks/execute-manual-instance.thunk.js

@@ -106,6 +106,7 @@ import { payloadSafetyStore } from "@ai-matrx/kit/payload-safety";
 import { netRequests } from "../../../../host/diagnostics.js";
 import { buildRequestUserOverrides } from "../utils/request-user-overrides.js";
 import { buildToolInjection } from "../utils/build-tool-injection.js";
+import { mergeHostTurnContext } from "../utils/host-turn.js";
 import { resolveRequestOverrides } from "../utils/request-overrides.js";
 import { attachOutputKindsFromState, attachSkillConfigFromState } from "../utils/build-skill-config-for-request.js";
 import { isUiGateKey } from "../../agent-settings/ui-gates.js";
@@ -289,7 +290,11 @@ async function assembleManualRequest(state, conversationId, opts) {
   if (agent.variableDefinitions?.length) {
     request.variable_definitions = agent.variableDefinitions;
   }
-  if (context) request.context = context;
+  const mergedContext = mergeHostTurnContext(
+    context,
+    injection.hostContext
+  );
+  if (mergedContext) request.context = mergedContext;
   request.context_withheld = context_withheld;
   if (page_context) request.page_context = page_context;
   if (context_surfaces) request.context_surfaces = context_surfaces;

package/dist/agents/redux/execution-system/thunks/notify-and-play-dispatcher.d.ts

@@ -0,0 +1,58 @@
+/**
+ * createNotifyAndPlayDispatcher — the one dispatcher for tool families that run
+ * IMMEDIATELY with no approval pause (scribe playback, the war-room master's
+ * notify-and-watch tools). It validates args against the family's Zod schema,
+ * runs the family's handler, and reports through `postDelegatedToolOutcome`.
+ * A family supplies only its name check, its registry lookup and its label.
+ *
+ * Safety without an approval gate:
+ *   1. Args are Zod-validated before anything runs (malformed => clean error).
+ *   2. The handler resolves its own target and refuses cleanly (`ok:false`).
+ *   3. Every result goes through the single funnel so the hard-suspended loop
+ *      resumes exactly once. The dispatcher never throws.
+ */
+import type { ThunkDispatch } from "redux-thunk";
+import type { UnknownAction } from "@reduxjs/toolkit";
+import type { z } from "zod";
+export interface NotifyAndPlayPayload {
+    conversationId: string;
+    requestId: string;
+    callId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+}
+interface NotifyAndPlayContext<S> {
+    conversationId: string;
+    callId: string;
+    userId: string;
+    dispatch: ThunkDispatch<S, unknown, UnknownAction>;
+    getState: () => S;
+}
+export interface NotifyAndPlayEntry<S> {
+    schema: z.ZodTypeAny;
+    handler: {
+        run: (args: never, ctx: NotifyAndPlayContext<S>) => Promise<unknown>;
+    };
+}
+export declare function createNotifyAndPlayDispatcher<S extends {
+    userAuth?: {
+        id?: string | null;
+    } | null;
+}>(options: {
+    /** Redux action type prefix, e.g. "scribeTools/dispatch". */
+    typePrefix: string;
+    /** Human label used in the unknown-tool message, e.g. "scribe". */
+    family: string;
+    isToolName: (name: string) => boolean;
+    getEntry: (name: string) => NotifyAndPlayEntry<S> | undefined;
+}): import("@reduxjs/toolkit").AsyncThunk<void, NotifyAndPlayPayload, {
+    dispatch?: ThunkDispatch<unknown, unknown, UnknownAction>;
+    extra?: unknown;
+    rejectValue?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+    state: S;
+}>;
+export {};

package/dist/agents/redux/execution-system/thunks/notify-and-play-dispatcher.js

@@ -0,0 +1,62 @@
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { extractErrorMessage } from "@ai-matrx/data/net";
+import { postDelegatedToolOutcome } from "./post-delegated-tool-outcome.js";
+function createNotifyAndPlayDispatcher(options) {
+  const { typePrefix, family, isToolName, getEntry } = options;
+  return createAsyncThunk(
+    typePrefix,
+    async ({ conversationId, requestId, callId, toolName, args }, { dispatch, getState }) => {
+      const userId = getState().userAuth?.id ?? null;
+      const base = { conversationId, requestId, callId, toolName };
+      const fail = (errorType, message, durationMs) => postDelegatedToolOutcome(dispatch, {
+        ...base,
+        output: { ok: false, reason: errorType, message },
+        error: { type: errorType, message },
+        durationMs
+      });
+      if (!userId) {
+        fail("unauthenticated", "user not authenticated");
+        return;
+      }
+      const entry = isToolName(toolName) ? getEntry(toolName) : void 0;
+      if (!entry) {
+        fail("unknown_tool", `Unknown ${family} tool: ${toolName}`);
+        return;
+      }
+      const parsed = entry.schema.safeParse(args);
+      if (!parsed.success) {
+        fail(
+          "schema",
+          `args failed schema for ${toolName}: ${JSON.stringify(
+            parsed.error.format()
+          )}`
+        );
+        return;
+      }
+      const startedAt = performance.now();
+      try {
+        const result = await entry.handler.run(parsed.data, {
+          conversationId,
+          callId,
+          userId,
+          dispatch,
+          getState
+        });
+        postDelegatedToolOutcome(dispatch, {
+          ...base,
+          output: result,
+          durationMs: Math.round(performance.now() - startedAt)
+        });
+      } catch (cause) {
+        fail(
+          "handler_threw",
+          extractErrorMessage(cause),
+          Math.round(performance.now() - startedAt)
+        );
+      }
+    }
+  );
+}
+export {
+  createNotifyAndPlayDispatcher
+};

package/dist/agents/redux/execution-system/thunks/post-delegated-tool-outcome.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The ONE way a client-delegated tool call reports its outcome: close the
+ * lifecycle row (so the live tool card stops waiting) AND post the result
+ * through the single `submitToolResult` funnel (so the hard-suspended loop
+ * resumes exactly once). Every dispatcher — scribe, war-room, surface client
+ * tools, surface writes — calls this instead of hand-writing the pair.
+ */
+import type { ChatDispatch } from "../../../../store/root-state.js";
+export interface DelegatedToolOutcome {
+    conversationId: string;
+    requestId: string;
+    callId: string;
+    toolName: string;
+    /** The result body posted to the loop and shown on the card. */
+    output: Record<string, unknown>;
+    /** Present => the call failed; `type` is the lifecycle errorType. */
+    error?: {
+        type: string;
+        message: string;
+    };
+    durationMs?: number;
+}
+export declare function postDelegatedToolOutcome(dispatch: ChatDispatch, { conversationId, requestId, callId, toolName, output, error, durationMs, }: DelegatedToolOutcome): void;

package/dist/agents/redux/execution-system/thunks/post-delegated-tool-outcome.js

@@ -0,0 +1,37 @@
+import { submitToolResult } from "../../../api/submit-tool-results.js";
+import { upsertToolLifecycle } from "../active-requests/active-requests.slice.js";
+function postDelegatedToolOutcome(dispatch, {
+  conversationId,
+  requestId,
+  callId,
+  toolName,
+  output,
+  error,
+  durationMs
+}) {
+  dispatch(
+    upsertToolLifecycle({
+      requestId,
+      callId,
+      toolName,
+      status: error ? "error" : "completed",
+      isDelegated: true,
+      result: output,
+      ...error ? { errorType: error.type, errorMessage: error.message } : {}
+    })
+  );
+  dispatch(
+    submitToolResult({
+      conversationId,
+      call_id: callId,
+      tool_name: toolName,
+      is_error: Boolean(error),
+      output,
+      ...error ? { error_message: error.message } : {},
+      ...durationMs !== void 0 ? { duration_ms: durationMs } : {}
+    })
+  );
+}
+export {
+  postDelegatedToolOutcome
+};

package/dist/agents/redux/execution-system/thunks/resume-instance.thunk.js

@@ -11,6 +11,7 @@ import {
   warmLocalEngineForConversation
 } from "./resolve-base-url.js";
 import { buildToolInjection } from "../utils/build-tool-injection.js";
+import { mergeHostTurnContext } from "../utils/host-turn.js";
 import {
   hasAbortController,
   whenAbortControllerReleased
@@ -135,7 +136,8 @@ const resumeInstance = createAsyncThunk(
       }
       resumeBackend = backend;
       const injection = await buildToolInjection(state, conversationId, {
-        mode: "additive"
+        mode: "additive",
+        phase: "resume"
       });
       await dispatch(refreshSurfaceScope({ conversationId })).unwrap().catch(
         (error) => console.error(
@@ -171,7 +173,13 @@ const resumeInstance = createAsyncThunk(
       ).filter((id) => typeof id === "string" && id.length > 0);
       const body = {
         user_request_id: userRequestId,
-        ...context && { context },
+        ...(() => {
+          const merged = mergeHostTurnContext(
+            context,
+            injection.hostContext
+          );
+          return merged ? { context: merged } : {};
+        })(),
         context_withheld,
         ...page_context && { page_context },
         ...context_surfaces && { context_surfaces },

package/dist/agents/redux/execution-system/utils/build-tool-injection.d.ts

@@ -21,6 +21,7 @@ import type { ChatRootState } from "../../../../store/root-state.js";
 import type { ToolInjectionResult, ToolSpec } from "../../../types/tool-injection.types.js";
 import "../client-capabilities/register-all.js";
 import type { UserOverrides } from "../../../types/request.types.js";
+import type { ChatHostTurnPhase } from "../../../../host/contract.js";
 interface BuildOptions {
     mode?: "additive" | "replace";
     /**
@@ -29,6 +30,12 @@ interface BuildOptions {
      * aren't in the slice (e.g. an agent-as-tool projection).
      */
     seedTools?: ToolSpec[];
+    /**
+     * Which moment of the turn this request is for — handed to the host's turn port
+     * (`registry.contextSources`). A start latches the device reference + ask/act mode for the turn.
+     * Default: "start".
+     */
+    phase?: ChatHostTurnPhase;
 }
 export declare function buildToolInjection(state: ChatRootState, conversationId: string, options?: BuildOptions): Promise<ToolInjectionResult>;
 /**

package/dist/agents/redux/execution-system/utils/build-tool-injection.js

@@ -39,6 +39,7 @@ import {
   announceWithheldSurfaceWriteTools,
   resolveRunOutputContract
 } from "./output-contract-guard.js";
+import { collectHostTurnContribution } from "./host-turn.js";
 import {
   isToolBlocked,
   selectBlockedToolPatterns
@@ -194,12 +195,15 @@ async function buildToolInjection(state, conversationId, options = {}) {
     }
   }
   const providers = getRegisteredCapabilities();
-  const resolved = await Promise.all(
-    providers.map(async (p) => {
-      const payload = await p.selectPayload(state, conversationId);
-      return payload == null ? null : { name: p.name, payload, stateless: p.stateless ?? false };
-    })
-  );
+  const [resolved, hostTurn] = await Promise.all([
+    Promise.all(
+      providers.map(async (p) => {
+        const payload = await p.selectPayload(state, conversationId);
+        return payload == null ? null : { name: p.name, payload, stateless: p.stateless ?? false };
+      })
+    ),
+    collectHostTurnContribution(state, conversationId, options.phase ?? "start")
+  ]);
   let client;
   const activeCapabilities = [];
   const stateMap = {};
@@ -209,6 +213,11 @@ async function buildToolInjection(state, conversationId, options = {}) {
     if (entry.stateless) continue;
     stateMap[entry.name] = entry.payload;
   }
+  for (const [name, payload] of Object.entries(hostTurn?.capabilities ?? {})) {
+    if (activeCapabilities.includes(name)) continue;
+    activeCapabilities.push(name);
+    if (payload != null) stateMap[name] = payload;
+  }
   const desktopTargetInstanceId = selectDesktopTargetInstanceId(state);
   const existingDesktopState = stateMap["desktop-native"];
   if (desktopTargetInstanceId && existingDesktopState) {
@@ -235,6 +244,9 @@ async function buildToolInjection(state, conversationId, options = {}) {
     else result.tools = allTools;
   }
   if (client) result.client = client;
+  if (hostTurn?.context && Object.keys(hostTurn.context).length > 0) {
+    result.hostContext = hostTurn.context;
+  }
   return result;
 }
 function selectEffectiveAutoTools(state, conversationId) {

package/dist/agents/redux/execution-system/utils/host-turn.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The host's per-turn contribution (`registry.contextSources`) and what the package keeps from it.
+ *
+ * `buildToolInjection` — the one envelope builder for execute, manual and resume — asks the
+ * host once per request: which server-registered client capabilities it offers (with their
+ * `client.state` payloads), which entries join the request's `context`, and an opaque device
+ * reference for the turn. The wait is bounded (`HOST_TURN_BUDGET_MS`): a host that answers too
+ * late, or throws, is skipped for that request and the skip is announced through diagnostics —
+ * a slow host never stalls a send.
+ *
+ * The device reference and the person's ask/act choice are LATCHED when the turn starts (the
+ * person's send) and handed to `deviceTools.invoke` for every call of that turn, resumes
+ * included — so switching tabs or flipping the mode mid-run never moves a run already going.
+ */
+import type { ChatRootState } from "../../../../store/root-state.js";
+import type { ChatDevicePermissionMode, ChatHostTurnContribution, ChatHostTurnPhase } from "../../../../host/contract.js";
+/** The longest a request waits on the host's turn contribution. */
+export declare const HOST_TURN_BUDGET_MS = 1500;
+/** Prefs key for one agent's device-tool mode (`"ask"` | `"act"`). */
+export declare const DEVICE_PERMISSION_MODE_KEY = "chat.device-tools.permission-mode";
+export declare function devicePermissionModeKey(agentId: string | null): string;
+/** The person's stored ask/act choice for this agent; `"ask"` until they choose. */
+export declare function readDevicePermissionMode(agentId: string | null): ChatDevicePermissionMode;
+export declare function writeDevicePermissionMode(agentId: string | null, mode: ChatDevicePermissionMode): void;
+interface LatchedTurn {
+    agentId: string | null;
+    permissionMode: ChatDevicePermissionMode;
+    deviceRef?: unknown;
+}
+/** What the current turn of this conversation latched at send time (device tools read this). */
+export declare function getLatchedTurn(conversationId: string): LatchedTurn | null;
+/** Test seam: forget every latched turn. */
+export declare function resetLatchedTurns(): void;
+/**
+ * Ask every registered context source for this request's contribution (in parallel, each
+ * bounded). On a start, latch the device reference and the ask/act mode for the turn; a resume
+ * keeps what the start latched (a resume whose start predates this page load latches then).
+ */
+export declare function collectHostTurnContribution(state: ChatRootState, conversationId: string, phase: ChatHostTurnPhase): Promise<ChatHostTurnContribution | null>;
+/**
+ * Merge the host's context entries under what the request already carries: a key the person
+ * or the agent set always wins. Returns the original object when the host adds nothing.
+ */
+export declare function mergeHostTurnContext<T extends Record<string, unknown> | undefined>(existing: T, hostContext: Readonly<Record<string, unknown>> | undefined): T | Record<string, unknown>;
+export {};

package/dist/agents/redux/execution-system/utils/host-turn.js

@@ -0,0 +1,119 @@
+import { getChatHost, isChatHostConfigured } from "../../../../host/configure.js";
+const HOST_TURN_BUDGET_MS = 1500;
+const DEVICE_PERMISSION_MODE_KEY = "chat.device-tools.permission-mode";
+function devicePermissionModeKey(agentId) {
+  return `${DEVICE_PERMISSION_MODE_KEY}:${agentId ?? "default"}`;
+}
+function readDevicePermissionMode(agentId) {
+  if (!isChatHostConfigured()) return "ask";
+  const prefs = getChatHost().prefs;
+  const own = prefs.get(devicePermissionModeKey(agentId));
+  if (own === "ask" || own === "act") return own;
+  const fallback = prefs.get(devicePermissionModeKey(null));
+  return fallback === "act" ? "act" : "ask";
+}
+function writeDevicePermissionMode(agentId, mode) {
+  if (!isChatHostConfigured()) return;
+  getChatHost().prefs.set(devicePermissionModeKey(agentId), mode);
+}
+const latchedByConversation = /* @__PURE__ */ new Map();
+function getLatchedTurn(conversationId) {
+  return latchedByConversation.get(conversationId) ?? null;
+}
+function resetLatchedTurns() {
+  latchedByConversation.clear();
+}
+function agentIdOf(state, conversationId) {
+  return state.conversations?.byConversationId?.[conversationId]?.agentId ?? null;
+}
+function announceSkip(sourceId, conversationId, phase, cause) {
+  const message = cause === "timeout" ? `Context source "${sourceId}" did not answer within ${HOST_TURN_BUDGET_MS}ms; this ${phase} request went without it.` : `Context source "${sourceId}" failed; this ${phase} request went without it.`;
+  try {
+    getChatHost().diagnostics.capture(cause === "timeout" ? new Error(message) : cause, {
+      area: "host-turn",
+      code: cause === "timeout" ? "host_turn_timeout" : "host_turn_failed",
+      detail: { sourceId, conversationId, phase, message }
+    });
+  } catch {
+    console.warn(`[host-turn] ${message}`, cause);
+  }
+}
+async function askSource(source, input) {
+  let timer;
+  const outcome = await Promise.race([
+    Promise.resolve().then(() => source.contribute(input)).then((value) => ({ ok: true, value })).catch((error) => ({ ok: false, error })),
+    new Promise((resolve) => {
+      timer = setTimeout(() => resolve({ ok: false, error: "timeout" }), HOST_TURN_BUDGET_MS);
+    })
+  ]);
+  if (timer) clearTimeout(timer);
+  if (outcome.ok) return outcome.value ?? null;
+  announceSkip(source.id, input.conversationId, input.phase, outcome.error);
+  return null;
+}
+function mergeContributions(parts) {
+  const capabilities = {};
+  const context = {};
+  let deviceRef = void 0;
+  let any = false;
+  for (const part of parts) {
+    if (!part) continue;
+    any = true;
+    for (const [name, payload] of Object.entries(part.capabilities ?? {})) {
+      if (!(name in capabilities)) capabilities[name] = payload;
+    }
+    for (const [key, value] of Object.entries(part.context ?? {})) {
+      if (!(key in context)) context[key] = value;
+    }
+    if (deviceRef === void 0 && part.deviceRef !== void 0) deviceRef = part.deviceRef;
+  }
+  if (!any) return null;
+  return {
+    ...Object.keys(capabilities).length > 0 && { capabilities },
+    ...Object.keys(context).length > 0 && { context },
+    ...deviceRef !== void 0 && { deviceRef }
+  };
+}
+async function collectHostTurnContribution(state, conversationId, phase) {
+  if (!isChatHostConfigured()) return null;
+  const host = getChatHost();
+  const agentId = agentIdOf(state, conversationId);
+  const sources = host.registry.contextSources ?? [];
+  const input = { conversationId, agentId, phase };
+  const contribution = sources.length > 0 ? mergeContributions(await Promise.all(sources.map((source) => askSource(source, input)))) : null;
+  if (host.deviceTools) {
+    const prior = latchedByConversation.get(conversationId);
+    if (phase === "start" || !prior) {
+      latchedByConversation.set(conversationId, {
+        agentId,
+        permissionMode: readDevicePermissionMode(agentId),
+        ...contribution?.deviceRef !== void 0 && { deviceRef: contribution.deviceRef }
+      });
+    }
+  }
+  return contribution;
+}
+function mergeHostTurnContext(existing, hostContext) {
+  if (!hostContext) return existing;
+  const keys = Object.keys(hostContext);
+  if (keys.length === 0) return existing;
+  const merged = { ...existing ?? {} };
+  let added = false;
+  for (const key of keys) {
+    if (key in merged) continue;
+    merged[key] = hostContext[key];
+    added = true;
+  }
+  return added ? merged : existing;
+}
+export {
+  DEVICE_PERMISSION_MODE_KEY,
+  HOST_TURN_BUDGET_MS,
+  collectHostTurnContribution,
+  devicePermissionModeKey,
+  getLatchedTurn,
+  mergeHostTurnContext,
+  readDevicePermissionMode,
+  resetLatchedTurns,
+  writeDevicePermissionMode
+};

package/dist/agents/redux/proposed-directives/proposedDirectivesSlice.d.ts

@@ -71,7 +71,7 @@ export declare const selectProposedDirectives: (conversationId: string) => ((sta
     voiceAgent: import("../../../voice-agent/types.js").VoiceAgentState;
     agentDefinition: import("../../types/agent-definition.types.js").AgentDefinitionSliceState;
     conversationList: import("../conversation-list/conversation-list.types.js").ConversationListState;
-    conversationHistory: import("../conversation-history/index.js").ConversationHistoryState;
+    conversationHistory: import("../conversation-history/types.js").ConversationHistoryState;
     agentShortcut: import("../agent-shortcuts/types.js").AgentShortcutSliceState;
     agentShortcutCategory: import("../agent-shortcut-categories/types.js").AgentShortcutCategorySliceState;
     surfaceUserState: import("../../../surfaces/redux/userStateSlice.js").SurfaceUserStateSlice;