From a85f7efb1d3e8c7335c0e0bebbe6f9522ae42e72 Mon Sep 17 00:00:00 2001 From: Maxim Harizanov Date: Wed, 18 Feb 2026 20:15:23 +0200 Subject: [PATCH] fix(copilot): keep notifications visible and detect marker via message lookup --- src/plugin-interface.ts | 2 +- src/plugin/chat-headers.test.ts | 81 ++++++++++++++++++------- src/plugin/chat-headers.ts | 69 +++++++++++++-------- src/shared/internal-initiator-marker.ts | 2 - 4 files changed, 104 insertions(+), 50 deletions(-) diff --git a/src/plugin-interface.ts b/src/plugin-interface.ts index 19d5b600..e6849779 100644 --- a/src/plugin-interface.ts +++ b/src/plugin-interface.ts @@ -36,7 +36,7 @@ export function createPluginInterface(args: { await handler(input, output) }, - "chat.headers": createChatHeadersHandler(), + "chat.headers": createChatHeadersHandler({ ctx }), "chat.message": createChatMessageHandler({ ctx, diff --git a/src/plugin/chat-headers.test.ts b/src/plugin/chat-headers.test.ts index 1114f4fb..82653de8 100644 --- a/src/plugin/chat-headers.test.ts +++ b/src/plugin/chat-headers.test.ts @@ -4,22 +4,34 @@ import { OMO_INTERNAL_INITIATOR_MARKER } from "../shared" import { createChatHeadersHandler } from "./chat-headers" describe("createChatHeadersHandler", () => { - test("sets x-initiator=agent for Copilot internal synthetic marker messages", async () => { - const handler = createChatHeadersHandler() + test("sets x-initiator=agent for Copilot internal marker messages", async () => { + const handler = createChatHeadersHandler({ + ctx: { + client: { + session: { + message: async () => ({ + data: { + parts: [ + { + type: "text", + text: `notification\n${OMO_INTERNAL_INITIATOR_MARKER}`, + }, + ], + }, + }), + }, + }, + } as never, + }) const output: { headers: Record } = { headers: {} } await handler( { + sessionID: "ses_1", provider: { id: "github-copilot" }, message: { - info: { role: "user" }, - parts: [ - { - type: "text", - text: `notification\n${OMO_INTERNAL_INITIATOR_MARKER}`, - synthetic: true, - }, - ], + id: "msg_1", + role: "user", }, }, output, @@ -29,21 +41,33 @@ describe("createChatHeadersHandler", () => { }) test("does not override non-copilot providers", async () => { - const handler = createChatHeadersHandler() + const handler = createChatHeadersHandler({ + ctx: { + client: { + session: { + message: async () => ({ + data: { + parts: [ + { + type: "text", + text: `notification\n${OMO_INTERNAL_INITIATOR_MARKER}`, + }, + ], + }, + }), + }, + }, + } as never, + }) const output: { headers: Record } = { headers: {} } await handler( { + sessionID: "ses_1", provider: { id: "openai" }, message: { - info: { role: "user" }, - parts: [ - { - type: "text", - text: `notification\n${OMO_INTERNAL_INITIATOR_MARKER}`, - synthetic: true, - }, - ], + id: "msg_1", + role: "user", }, }, output, @@ -53,15 +77,28 @@ describe("createChatHeadersHandler", () => { }) test("does not override regular user messages", async () => { - const handler = createChatHeadersHandler() + const handler = createChatHeadersHandler({ + ctx: { + client: { + session: { + message: async () => ({ + data: { + parts: [{ type: "text", text: "normal user message" }], + }, + }), + }, + }, + } as never, + }) const output: { headers: Record } = { headers: {} } await handler( { + sessionID: "ses_1", provider: { id: "github-copilot" }, message: { - info: { role: "user" }, - parts: [{ type: "text", text: "normal user message" }], + id: "msg_1", + role: "user", }, }, output, diff --git a/src/plugin/chat-headers.ts b/src/plugin/chat-headers.ts index 4e2a4225..d28c9267 100644 --- a/src/plugin/chat-headers.ts +++ b/src/plugin/chat-headers.ts @@ -1,10 +1,12 @@ import { OMO_INTERNAL_INITIATOR_MARKER } from "../shared" +import type { PluginContext } from "./types" type ChatHeadersInput = { + sessionID: string provider: { id: string } message: { - info?: { role?: string } - parts?: Array<{ type?: string; text?: string; synthetic?: boolean }> + id?: string + role?: string } } @@ -19,28 +21,20 @@ function isRecord(value: unknown): value is Record { function buildChatHeadersInput(raw: unknown): ChatHeadersInput | null { if (!isRecord(raw)) return null + const sessionID = raw.sessionID const provider = raw.provider const message = raw.message + if (typeof sessionID !== "string") return null if (!isRecord(provider) || typeof provider.id !== "string") return null if (!isRecord(message)) return null - const info = isRecord(message.info) ? message.info : undefined - const rawParts = Array.isArray(message.parts) ? message.parts : undefined - - const parts = rawParts - ?.filter(isRecord) - .map((part) => ({ - type: typeof part.type === "string" ? part.type : undefined, - text: typeof part.text === "string" ? part.text : undefined, - synthetic: part.synthetic === true, - })) - return { + sessionID, provider: { id: provider.id }, message: { - info: info ? { role: typeof info.role === "string" ? info.role : undefined } : undefined, - parts, + id: typeof message.id === "string" ? message.id : undefined, + role: typeof message.role === "string" ? message.role : undefined, }, } } @@ -57,28 +51,53 @@ function isCopilotProvider(providerID: string): boolean { return providerID === "github-copilot" || providerID === "github-copilot-enterprise" } -function isOmoInternalMessage(input: ChatHeadersInput): boolean { - if (input.message.info?.role !== "user") { +async function hasInternalMarker( + client: PluginContext["client"], + sessionID: string, + messageID: string, +): Promise { + try { + const response = await client.session.message({ + path: { id: sessionID, messageID }, + }) + + const data = response.data + if (!isRecord(data) || !Array.isArray(data.parts)) return false + + return data.parts.some((part) => { + if (!isRecord(part) || part.type !== "text" || typeof part.text !== "string") { + return false + } + + return part.text.includes(OMO_INTERNAL_INITIATOR_MARKER) + }) + } catch { + return false + } +} + +async function isOmoInternalMessage(input: ChatHeadersInput, client: PluginContext["client"]): Promise { + if (input.message.role !== "user") { return false } - return input.message.parts?.some((part) => { - if (part.type !== "text" || !part.text || part.synthetic !== true) { - return false - } + if (!input.message.id) { + return false + } - return part.text.includes(OMO_INTERNAL_INITIATOR_MARKER) - }) ?? false + return hasInternalMarker(client, input.sessionID, input.message.id) } -export function createChatHeadersHandler(): (input: unknown, output: unknown) => Promise { +export function createChatHeadersHandler(args: { ctx: PluginContext }): (input: unknown, output: unknown) => Promise { + const { ctx } = args + return async (input, output): Promise => { const normalizedInput = buildChatHeadersInput(input) if (!normalizedInput) return if (!isChatHeadersOutput(output)) return if (!isCopilotProvider(normalizedInput.provider.id)) return - if (!isOmoInternalMessage(normalizedInput)) return + if (!(await isOmoInternalMessage(normalizedInput, ctx.client))) return output.headers["x-initiator"] = "agent" } diff --git a/src/shared/internal-initiator-marker.ts b/src/shared/internal-initiator-marker.ts index cc0b1001..3e19c581 100644 --- a/src/shared/internal-initiator-marker.ts +++ b/src/shared/internal-initiator-marker.ts @@ -3,11 +3,9 @@ export const OMO_INTERNAL_INITIATOR_MARKER = "" export function createInternalAgentTextPart(text: string): { type: "text" text: string - synthetic: true } { return { type: "text", text: `${text}\n${OMO_INTERNAL_INITIATOR_MARKER}`, - synthetic: true, } }