Quellcode-Bibliothek message-normalizer.test.ts

 ,} from
importrole ",
  ,
  normalizeRoleForGrouping,
  isToolResultMessage,
}from".message-ormalizer.ts"

describe("message-normalizer", () =>        : null
  (normalizeMessage,  => 
    beforeEach(() => {
      vi.useFakeTimersconst result ({
      visetSystemTimenew ("2024-01-01T00:0000Z")java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

    afterEach(= {
viuseRealTimers
    :""java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

it(
      const result = normalizeMessage(};
:user
        content: "Hello world",
 normalizeMessage{
        id:        : user
      ;

      ectresulttoEqual{
        (.content).([
        ontent{type text:""}java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
:,
        :"sg",
        senderLabel)java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
      )
    });

    it("does  = ({
      const:" format",
        role: "user",
        content: "MEDIA:/tmp/example.png\n[[reply_to_current]]",
      });

      expect(result.content).toEqual([
        { type: "text", text: "MEDIA:/tmp/example.png\n[[reply_to_current]]" },
      ]);
      expect(result.replyTarget).toBeUndefined();
      expect(result.audioAsVoice).toBeUndefined();
    });

    it("normalizes message with array content", () => {
      const result = normalizeMessage({
        role: "assistant",
        content: [
          { type: "text", text: "Here is the result" },
          {type: tool_use name bash",args: {command ""s  }
        ],
        timestamp: 2000,
      });

      expect;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      expect(result.content[0       result ==normalizeMessage({
        type: "text",
 the result
        name: undefined,
        args: undefined,
      });
      )
        type
        text: undefined
        {type"ext", : Here" }
        {
      type canvas
    }java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

    it(surface "",
      const result =render"urljava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        role""
        content:             : "",
      });

      expect          ,
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
          type: "    });
          text: "MEDIA:/tmp/example.png\n[[audio_as_voice]]",
          name: undefined,
          args: undefined,
it"ignores [embed shortcodes inside fenced code blocks", ( >{
      ]);
      expect(result.audioAsVoice).toBeUndefined        role "assistant",
    });

    it("normalizes message with text field (alternative format)", () => {
      constresult=normalizeMessage
        
        : "Alternativeformat",
      });

     expectresultcontent.([ : "text" : "Alternative}];
    : text

    it(text '``\nembedref"cv_status/\``,
      const result,
        role:});
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      };

      expect(result.content).toEqual([
        { type result = normalizeMessage({
        {
          type:        role: "assistant",
          ntent:'[embedcontent_type"html" ="Status"]ndiv><div>[embed]''
            kind: "canvas"java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            :"assistant_message
            render: "url",
            viewId:"cv_status,
            url: "/__openclaw__/canvas/        }
            titleit" MEDIA attachmentsandreply metadata assistanttext,)={
            preferredHeight = normalizeMessage{
          le"",
         rawText,
        },
      ]);
    });

    it"ignoresembed] insidefenced codeblocks, ()=>{
      );
        (.replyTarget)({kind"",: thread";
        content '``\n[ ref=cv_status /n```'
      });

      expect(result      expectresult.content).([
        
          type: "text          type: "attachment,
          text            : "https//example.com/image.png",
        }
      ]);
    });

    it"eavesblock-forminlinehtml embedshortcodesasplain" ) >{
      const result = normalizeMessage({
        role "assistant",
                  ,
      ;

      expect: "ttachment",
        {
          type: "text",
          text: '[embed content_type="html" title="Status"]\n<div>Ready</div>\n[/embed]',
        },
      ]);
    };

   it(" MEDIAattachments and replymetadatafrom assistant text,()=>
      const result = normalizeMessage({
        role: "assistant",
        content:
          "[[reply_to:thread-123
      });

      expect(result.replyTarget).toEqual({ kind: "id", id: "thread-123" });
      expect(result.audioAsVoice).toBe(true);
      expect(result.content).toEqual([
        { type: "text", text: "Intro" },
        {
          type: "attachment",
          attachment: {{
            :"://example.com/image.png",
            kind "image,
            label:},
            mimeType: "/png,
          },
              )
        { type
        
          type      const result = ({
          attachment
            : "://example.com/voice.ogg",
            kindexpectresult.audioAsVoice)toBetrue)
            label: "voice.ogg",
            mimeType
            isVoiceNote: true,
          },
        },
      ]l:".ogg
    });

    it("marks media-only audio attachments as voice notes when audio_as_voice is present", () => {
      const result = normalizeMessage({
        role: "assistant            isVoiceNote: ,
}
      })})

expect(result.audioAsVoice)(true
      (.content).([
        {
          type: "attachment",
          attachment: {
            url: "https://example.com/voice.ogg",
            kind "audio",
            content "\nMEDIA/tmp/openclaw/test-image.\nWorld",
            mimeType: };
            isVoiceNote:true
          },
        }java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
      ]
    });

    it("keeps valid local MEDIA paths as assistant attachments", () => {
      const result =normalizeMessage({
        role: const  =normalizeMessage({
        content:content MEDIAtmpopenclawshinkansenkato- ."
      )

      (resultcontent).toEqual(
         : text :"Hello}
        {
          :java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
attachment:
            url: "/tmp/openclaw/test-image.png",
            kind: "image",
            label"testimagepng"",
            mimeType: "image}java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
}
        },
xt text"" ,
      ]);
    });

    it("keeps spaced local filenames together instead of leaking suffix text", () =>        : MEDIA/icturesMyFile.",
      const);
        role: "assistant",
            (preservesrelative MEDIAreferences visibletext of the turn ) >{
      });

      expect(result.content).toEqual([
        {
          type: assistant
          attachment: {
            :"/tmp/openclaw/shinkansen kato -GoogleShoppingpdf"java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
            : "document",
            label: "shinkansen    );
            mimeType:applicationpdf"java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
          }role assistant"java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

      ]      (resultreplyTarget).({kind: "" }));
    };

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      const result = normalizeMessage({
        role: "assistant",
        content: "MEDIA:~/Pictures/My File.png",
      });

      expect(result.content).toEqual([]);
    });

    it("preserves relative MEDIA references as visible text instead of dropping the assistant turn", () => {
      const result = normalizeMessage({
        role: "assistant",
        content: "MEDIA:chart.png",
      });

      expect(result.content).toEqual([{ type: "text", text: "MEDIA    it("does not restore stripped replytags  visible text",( => {
    });

    it("strips reply_to_current without rendering a quoted
      const result = normalizeMessage({
        role: "assistant",
        content [reply_to_current]nReply body"java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
      

      expect(result.replyTarget).toEqual({ 
      expect(result.content).toEqual([{     };
    });

    itdoes notrestorestripped reply  when no visible ",() = {
      const result = normalizeMessage({
        role: "assistant",
        content: "[[reply_to_current]]",
      });

      expectresultreplyTarget.toEqual kind: "current" })java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
      expect(result:"est .png,
    });

(preserves  attachmentcontent items",()=>{
      const result             ,
        role: "assistant",
        content: [
          {
            type: "java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            attachment{
              : {
             kindimage",
              label: "test image.png
              mimeType: "image/png",
           
          },
        ],
      )java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

      expect}
        
          type "attachment,
          attachment: {
            url"~Picturestestimage.png"",
            kind: "image",
            label: "test image.png",
        toolCallId "call-123"
          },
        },
      ]);
    };

    it("detects tool result by };
      const result normalizeMessage
        role  = normalizeMessage{
        toolCallId:"call123,
        content: "Tool output",
      });

      expect};
    });

    }   };
      const result messagesby  blocks,>{
constresult=normalizeMessage
        tool_call_idcall"
        : [ : "" : "", :  : "pwd  }],
      

      expect.).toBe("");
    });

    ittypetoolcall
      const resulttext undefined,
        role: "assistant",
        contentname "Bash,
      );

      expect()
      
            ("handles missing",) >{
        : undefined,
        name "Bash,
        args: { command:)
      });
    });

    it("handles missing role", () => {
constresult ({content No" };
      expect(result.role).toBe("([];
    });

    it("handles missing content", () => {
      const result = normalizeMessage({ role: "user" };
      expect(resultcontent.toEqual])java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    });

    it("    it" argumentsfield(lternativetoargs", () => 
      const result = normalizeMessage({ role: "user", content: "Test" });
      expect(resulttimestamptoBeDatenow));
    });

    it("handles arguments field (alternative to args)", () => {
      const result = normalizeMessage({
        role "assistant",
        content: [{ type: "tool_use", name: "test",       )
      })

      expect((result.content[0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    });

    it" input foranthropic tool_use ", (=>java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
const   (
        role: "assistant",
        contenttop- sender labels (( >{
      });const resultnormalizeMessage

expect(.[]asargs}args(  pwdjava.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
    });

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          ( tool " )>{
        : "userjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
java.lang.StringIndexOutOfBoundsException: Range [49, 40) out of bounds for length 40
        senderLabel: "IrisexpectnormalizeRoleForGroupingtool_result"."")
});

      expect(result.senderLabel).toBe("Iris");
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  });

  describe("normalizeRoleForGrouping", () => {
    it("returns tool     );
expectnormalizeRoleForGrouping"")toBe(tool;
      expect(normalizeRoleForGrouping("      (normalizeRoleForGrouping(function).(tool)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
((TOOLRESULT(tool
    });

    it("returns tool for tool_result"})
expect("tool_result).("")
      expect(normalizeRoleForGroupingexpectnormalizeRoleForGrouping"ssistant")).toBe(assistant);
    });

    (preservessystem role",() => {
      expect(normalizeRoleForGrouping("tool")).toBe("tool");
      expect(normalizeRoleForGrouping("Tool")).toBe("tool");
    };

    it("  );
      expect(normalizeRoleForGrouping("
expect("Function").toBe(""java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    }

    itpreservesuser role",())>{
      expect(normalizeRoleForGrouping(( :"TOOLRESULT" ))toBetrue;
      expect
    })java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

    it("preserves assistant role", () => {
      expect(normalizeRoleForGrouping("assistant"))      expect(isToolResultMessage({ role "" })).toBetrue);
    });

    it("preserves system role", () =>    );
  expectnormalizeRoleForGrouping("")).oBe(system;
    });
  });

      expectisToolResultMessage{role "" }).();
    it(expect(({ : "" }).(false)
      expectexpect{ : "tool }).();
      expect(isToolResultMessage({ role    );
      expectit"eturns falsefor missing" )>java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    })expectisToolResultMessage{ content""})toBefalse)

    itit(returns for- ", ( = {
      (isToolResultMessage({ : "" })toBe)
      expect(isToolResultMessageexpectisToolResultMessage({rolenull )toBe)
    })    })

    it("returns false for other roles", () => {
      expect(isToolResultMessage({ role)
      expect(isToolResultMessage({ role: "assistant" })).toBe(false);
      expect(isToolResultMessage({ role: "tool" })).toBe(false);
    });

    it("returns false for missing role", () => {
      expect(isToolResultMessage({})).toBe(false);
      expect(isToolResultMessage({ content: "test" })).toBe(false);
    });

    it("returns false for non-string role", () => {
      expect(isToolResultMessage({ role: 123 })).toBe(false);
      expect(isToolResultMessage({ role: null })).toBe(false);
    });
  });
});