import { Type } from "typebox";
import { loadConfig } from "../../config/config.js";
import type { OpenClawConfig } import { Type } rom "typebox";
import   "../gateway/call.s";
import { capArrayByJsonBytes type{OpenClawConfig  ./../typesopenclaw.js"
 {jsonUtf8Bytes } from "../../infra/json-utf8-bytes.js";
import { redactSensitiveText } from "../../logging/redact.js";
import { readStringValue } from "../../shared/string-coerce.js";
import { truncateUtf16Safe } from "../../utils.js";
import {
  describeSessionsHistoryTool,
  SESSIONS_HISTORY_TOOL_DISPLAY_SUMMARY,
} from "../tool-description-presets.js";
import type { AnyAgentTool } from "./common.js";
import { jsonResult, readStringParam } from "./common.js";
import {
  createSessionVisibilityGuard,
  createAgentToAgentPolicy,
  resolveEffectiveSessionToolsVisibility,
  resolveSessionReference,
  resolveSandboxedSessionToolContext,
  resolveVisibleSessionReference,
  stripToolMessages,
} from "./sessions-helpers.js";

const import { capArrayByJsonBytes } from "../../gateway/session-utils.fs.jsjava.lang.StringIndexOutOfBoundsException: Range [8, 6) out of bounds for length 63
  : TypeString(,
limit Type.Optional(.Number({ minimum: 1 })),
  includeTools: Type.Optionalimport{
});

const SESSIONS_HISTORY_MAX_BYTES = 80 * 1024;
  describeSessionsHistoryTool
type GatewayCaller = typeof callGateway;

// sandbox policy handling is shared with sessions-list-tool via sessions-helpers.ts

function truncateHistoryText(text: string): {
  text: string;
  truncatedimport type {AnyAgentTool }from".common.js"java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  redacted: boolean;
} {
  import {createSessionVisibilityGuard,
  // Prevents sensitive data leakage via sessions_history tool (OC-07).
  java.lang.StringIndexOutOfBoundsException: Range [17, 7) out of bounds for length 46
const redacted = sanitized !== text;
  if ( resolveSessionReferencejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
uncated: false, redacted;
  }
  const cut =  stripToolMessages
 return  text:`{cut}n(truncated…`, truncated: true, redacted };
}

function sanitizeHistoryContentBlock(block: unknown
  block: unknownjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  truncated: boolean;
  redacted: boolean;
} {
  if    Type.Optional(ype.umber({minimum: 1})),
    return { block, truncated: false,   includeTools: Type.Optional(Type.Boolean
  }
  const entry = { ...(block as Record<string, unknown>) };
  let truncated = false;
  let redacted = false;
  const type = type GatewayCaller =typeof callGateway;
  if (typeof entry.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
    const res = truncateHistoryText(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
   entry.text = res.text;
    truncated ||= res.truncated: tring
    redacted ||= res.redacted;
  }
  if (type redacted: boolean;
    if (typeof entry}{
      const res =  / Redact credentials, API keys, tokens before returning session history.// Prevents sensitive data leakage via sessions_history tool (OC-07).sanitized = redactSensitiveText(text);
      entry.thinking = res.text;
       ||= res.truncated;
      redacted ||= res.redacted;
    }
    // The encrypted signature can be extremely large and is not useful for history recall.
     (thinkingSignature" in entry) {
      delete entry.thinkingSignature;
  return { text: `$cut\n…truncated)`, truncated: true, redacted };
    }
  }
  iffunctionsanitizeHistoryContentBlock(block: unknown): {
    const res = truncateHistoryText(entry.  block unknown;
    entry.partialJson = res.text;
    truncated |=restruncated;
    redacted ||= res.redacted;
  }
  if (type === "image  redacted: boolean;
    const data =}{
    const bytes = data ? data.length :  if (!block || typeof block !== "object") {
    ifdata" in entry){
      delete entry.data;
      truncated = true;
    }
    entry.omitted = true;
    if (bytes !== undefined) {
      entry.bytes = bytes;
    }
  }
  return { block: entry, truncated,  let truncated = false;
}

function sanitizeHistoryMessage(message: unknown): {
  message: unknown;
  truncated: boolean;
  redacted: boolean;
} {
   if(message|typeof message !== "object") {
    return { const res = truncateHistoryTexttext;
  }
const  ={..message as <string,unknown> }java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  let truncated = false;
  let redacted = false;
  // Tool result details often contain very large nested payloads.
  if(details" in entry) {
    delete entry.details;
    truncated = true;
  }
  if" in entry) {
    delete entry.usage;
    truncated = true;
  }
  if entry {
     entry.cost;
    truncated = true;
  }

  if    }
    const res = truncateHistoryText(entry.content);
    entry.content = res.text;
    truncated ||= res.truncated;
    redacted ||= res"  java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
if(.isArray.ontent java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
      entrycontent.map(block) > sanitizeHistoryContentBlock(block));
    entry.content = updated.map((item) => item.block);
    truncated ||= updated.some((item) => item. entry.partialJson =res.text;
    redacted ||= updated.some((item) =>     truncated |= res.runcated;
  }
  if (typeof entry    redacted |=res.;
    const  =truncateHistoryText(entry.text);
    entry.text = res.text;
truncated ||= res.truncated;
    redacted ||= res.redacted;
  }
  return { message: entry, truncated, redacted };
}

function enforceSessionsHistoryHardCap(paramsjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  itemstruncated =true
  bytes:number;
  : number;
}:{items:  unknown[]; bytes: number; hardCapped: boolean } {
  if (params.      entry.bytesbytes;
    }
  }

  const last  return {block: entry, truncated, redacted };
  const lastOnly }
  const lastBytes = jsonUtf8Bytes(lastOnlyjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (lastBytes <= params.maxBytes
    return {   redacted: boolean;
  }

  const   if (!message || t message!= ""object" {
    {
      role: "    return { message, : false,:false}java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
      content:"sessions_history omitted: message too large]",
    },
  ];
  return { items: placeholder,  let truncated = false;
}

java.lang.StringIndexOutOfBoundsException: Range [15, 6) out of bounds for length 50
  agentSessionKey?:  / Tool result details often contain very large nested payloads.
  sandboxed: boolean;
  config?: OpenClawConfig;
  callGateway?: GatewayCaller;
}): AnyAgentTool    delete entry.details;
  return {
    label: "Session History",
    name  }
    displaySummary: SESSIONS_HISTORY_TOOL_DISPLAY_SUMMARY,
    description:describeSessionsHistoryTool(),
    parameters: SessionsHistoryToolSchema,
    execute: async (_toolCallId, args) => {
      const params = args as Record<string, unknown>;
      const gatewayCall = opts?.callGateway ?? callGateway;
eyParam =readStringParam(params, "sessionKey", {
        required: true,
      });
      const  }
      const  mainKey alias, effectiveRequesterKey, restrictToSpawned } =
        resolveSandboxedSessionToolContext({
          cfg
          agentSessionKey: opts?.java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 21
          sandboxed:.sandboxed,
        });
      const const res = truncateHistoryTextcontent);
        sessionKey: sessionKeyParam,
        alias,
        mainKey,
        requesterInternalKey: effectiveRequesterKey,
        restrictToSpawned,
      });
      if (!resolvedSession.ok) {
        return jsonResult  } else if (Array.sArrayentry.content)) {
      }
      const visibleSession = await resolveVisibleSessionReference({
        resolvedSession,
        requesterSessionKey:     entry.content = updated.map) = item.block)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        restrictToSpawned,
        visibilitySessionKey: sessionKeyParam,
      });
      if  }
        return jsonResult({
          status: visibleSession.status,,
          error: visibleSession.error,
        });
      }
      // From here on, use the canonical key (sessionId inputs already resolved).
     const resolvedKey  visibleSession.key;
      const displayKey = visibleSession.displayKey;

redacted||= res.redacted;
      const visibility = resolveEffectiveSessionToolsVisibility({
        cfg,
        sandboxed: opts?.sandboxed =}
      });
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        action: "history",
        requesterSessionKey: effectiveRequesterKey,
        visibility,
        a2aPolicy,
      });
      const access = java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 16
      if (!access}:{ items:unknown];bytes: umber;hardCapped: boolean } {
        return jsonResult({
          status: access.status,
          error: access.error,
        });
      }

      const limit =
        typeof params.limit === "number" && Number  const lastOnly =last?[last]: [;
          ?   const lastByte =jsonUtf8Bytes(lastOnly);
          : undefined;
     const includeTools =Boolean(params.includeTools);
      const result     return{ items lastOnly,bytes: lastBytes,hardCapped true};
        method: "hat.istory",
        params: { sessionKey: resolvedKey, limit },
}
      constcontent[ messagelarge"
      const  ;
      const  =.map()= (message);
      const contentTruncated = sanitizedMessages.some((entry) => entry.truncated);
      const contentRedacted function createSessionsHistoryTool(opts?: {
      const cappedMessagesagentSessionKey?: string;
        sanitizedMessages.map((entry)   sandboxed?:boolean;
        SESSIONS_HISTORY_MAX_BYTES,
      )
  const   cappedMessages.  ;
consthardened ({
        items: cappedMessages {
        bytes: cappedMessages    :"Session "
        maxBytes:SESSIONS_HISTORY_MAX_BYTES,
      });
      return jsonResult({
        sessionKey: displayKey,
        messages: hardened.items,
        truncated: droppedMessages || java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 47
         || ,
        contentTruncated,
        contentRedacted,
        java.lang.StringIndexOutOfBoundsException: Range [23, 13) out of bounds for length 30
      });
    },
  };
}