@bytetrue/byspace 0.1.0

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/providers/claude/sidechain-tracker.js

@@ -0,0 +1,374 @@
+import { mapClaudeCompletedToolCall, mapClaudeFailedToolCall, mapClaudeRunningToolCall, } from "./tool-call-mapper.js";
+import { buildToolCallDisplayModel } from "@bytetrue/byspace-protocol/tool-call-display";
+const MAX_SUB_AGENT_LOG_ENTRIES = 200;
+const MAX_SUB_AGENT_SUMMARY_CHARS = 160;
+function readTrimmedString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function isClaudeContentChunk(value) {
+    return Boolean(value && typeof value === "object" && typeof value.type === "string");
+}
+export class ClaudeSidechainTracker {
+    constructor(input) {
+        this.activeSidechains = new Map();
+        this.getToolInput = input.getToolInput;
+    }
+    handleMessage(message, parentToolUseId) {
+        const state = this.activeSidechains.get(parentToolUseId) ??
+            {
+                actions: [],
+                actionKeys: [],
+                nextActionIndex: 1,
+                actionIndexByKey: new Map(),
+                completedActionKeys: new Set(),
+            };
+        this.activeSidechains.set(parentToolUseId, state);
+        const contextUpdated = this.updateSubAgentContextFromTaskInput(state, parentToolUseId);
+        const actionCandidates = this.extractSubAgentActionCandidates(message);
+        const childTimelineItems = [
+            ...this.extractSubAgentTimelineItems(message),
+            ...this.extractSubAgentToolResults(message, state),
+        ];
+        let actionUpdated = false;
+        for (const action of actionCandidates) {
+            if (state.completedActionKeys.has(action.key))
+                continue;
+            if (this.appendSubAgentAction(state, action)) {
+                actionUpdated = true;
+                const toolCall = mapClaudeRunningToolCall({
+                    name: action.toolName,
+                    callId: action.key,
+                    input: action.input,
+                    output: null,
+                });
+                if (toolCall) {
+                    childTimelineItems.push(toolCall);
+                }
+            }
+        }
+        if (!contextUpdated && !actionUpdated && childTimelineItems.length === 0) {
+            return [];
+        }
+        const toolCall = mapClaudeRunningToolCall({
+            name: "Task",
+            callId: parentToolUseId,
+            input: null,
+            output: null,
+        });
+        if (!toolCall) {
+            return [];
+        }
+        const detail = {
+            type: "sub_agent",
+            ...(state.subAgentType ? { subAgentType: state.subAgentType } : {}),
+            ...(state.description ? { description: state.description } : {}),
+            log: state.actions
+                .map((action) => action.summary ? `[${action.toolName}] ${action.summary}` : `[${action.toolName}]`)
+                .join("\n"),
+            actions: [],
+        };
+        return [
+            {
+                type: "provider_subagent",
+                provider: "claude",
+                event: {
+                    type: "upsert",
+                    id: parentToolUseId,
+                    title: state.name ?? state.subAgentType ?? "Claude subagent",
+                    description: state.description ?? null,
+                    status: "running",
+                    toolCallId: parentToolUseId,
+                },
+            },
+            ...childTimelineItems.map((item) => ({
+                type: "provider_subagent",
+                provider: "claude",
+                event: { type: "timeline", id: parentToolUseId, item },
+            })),
+            {
+                type: "timeline",
+                item: {
+                    ...toolCall,
+                    detail,
+                },
+                provider: "claude",
+            },
+        ];
+    }
+    finishAll(status) {
+        const events = [];
+        for (const [id, state] of this.activeSidechains) {
+            events.push({
+                type: "provider_subagent",
+                provider: "claude",
+                event: {
+                    type: "upsert",
+                    id,
+                    title: state.name ?? state.subAgentType ?? "Claude subagent",
+                    description: state.description ?? null,
+                    status,
+                    toolCallId: id,
+                },
+            });
+        }
+        this.activeSidechains.clear();
+        return events;
+    }
+    finish(id, status) {
+        const state = this.activeSidechains.get(id);
+        if (!state)
+            return [];
+        this.activeSidechains.delete(id);
+        return [
+            {
+                type: "provider_subagent",
+                provider: "claude",
+                event: {
+                    type: "upsert",
+                    id,
+                    title: state.name ?? state.subAgentType ?? "Claude subagent",
+                    description: state.description ?? null,
+                    status,
+                    toolCallId: id,
+                },
+            },
+        ];
+    }
+    delete(toolUseId) {
+        this.activeSidechains.delete(toolUseId);
+    }
+    clear() {
+        this.activeSidechains.clear();
+    }
+    extractSubAgentTimelineItems(message) {
+        if (message.type !== "assistant" || !Array.isArray(message.message?.content)) {
+            return [];
+        }
+        const messageId = readTrimmedString(message.message.id);
+        const items = [];
+        for (const block of message.message.content) {
+            if (!isClaudeContentChunk(block))
+                continue;
+            if (block.type === "text") {
+                const text = readTrimmedString(block.text);
+                if (text) {
+                    items.push({
+                        type: "assistant_message",
+                        text,
+                        ...(messageId ? { messageId } : {}),
+                    });
+                }
+            }
+            else if (block.type === "thinking") {
+                const text = readTrimmedString(block.thinking);
+                if (text)
+                    items.push({ type: "reasoning", text });
+            }
+        }
+        return items;
+    }
+    extractSubAgentToolResults(message, state) {
+        const messageRecord = message;
+        const messageContainer = messageRecord.message;
+        const content = messageContainer?.content;
+        if (!Array.isArray(content))
+            return [];
+        const items = [];
+        for (const block of content) {
+            if (!isClaudeContentChunk(block) || !block.type.endsWith("tool_result"))
+                continue;
+            const callId = readTrimmedString(block.tool_use_id);
+            if (!callId || state.completedActionKeys.has(callId))
+                continue;
+            const actionIndex = state.actionIndexByKey.get(callId);
+            const action = actionIndex === undefined ? undefined : state.actions[actionIndex];
+            const toolName = action?.toolName ?? readTrimmedString(block.tool_name);
+            if (!toolName)
+                continue;
+            const params = {
+                name: toolName,
+                callId,
+                input: action?.input ?? null,
+                output: block.content ?? null,
+            };
+            const toolCall = block.is_error
+                ? mapClaudeFailedToolCall({ ...params, error: block })
+                : mapClaudeCompletedToolCall(params);
+            if (toolCall) {
+                state.completedActionKeys.add(callId);
+                items.push(toolCall);
+            }
+        }
+        return items;
+    }
+    updateSubAgentContextFromTaskInput(state, parentToolUseId) {
+        const taskInput = this.getToolInput(parentToolUseId);
+        const nextName = this.normalizeSubAgentText(taskInput?.name);
+        const nextSubAgentType = this.normalizeSubAgentText(taskInput?.subagent_type);
+        const nextDescription = this.normalizeSubAgentText(taskInput?.description);
+        let changed = false;
+        if (nextName && nextName !== state.name) {
+            state.name = nextName;
+            changed = true;
+        }
+        if (nextSubAgentType && nextSubAgentType !== state.subAgentType) {
+            state.subAgentType = nextSubAgentType;
+            changed = true;
+        }
+        if (nextDescription && nextDescription !== state.description) {
+            state.description = nextDescription;
+            changed = true;
+        }
+        return changed;
+    }
+    normalizeSubAgentText(value) {
+        const normalized = readTrimmedString(value)?.replace(/\s+/g, " ");
+        if (!normalized) {
+            return undefined;
+        }
+        if (normalized.length <= MAX_SUB_AGENT_SUMMARY_CHARS) {
+            return normalized;
+        }
+        return `${normalized.slice(0, MAX_SUB_AGENT_SUMMARY_CHARS)}...`;
+    }
+    extractAssistantMessageActions(message) {
+        const content = message.message?.content;
+        if (!Array.isArray(content)) {
+            return [];
+        }
+        const actions = [];
+        for (const block of content) {
+            if (!isClaudeContentChunk(block) ||
+                !(block.type === "tool_use" ||
+                    block.type === "mcp_tool_use" ||
+                    block.type === "server_tool_use") ||
+                typeof block.name !== "string") {
+                continue;
+            }
+            const key = readTrimmedString(block.id) ?? `assistant:${block.name}:${actions.length}`;
+            actions.push({
+                key,
+                toolName: block.name,
+                input: block.input ?? null,
+            });
+        }
+        return actions;
+    }
+    extractStreamEventActions(message) {
+        const event = message.event;
+        if (event.type !== "content_block_start") {
+            return [];
+        }
+        const block = isClaudeContentChunk(event.content_block) ? event.content_block : null;
+        if (!block ||
+            !(block.type === "tool_use" ||
+                block.type === "mcp_tool_use" ||
+                block.type === "server_tool_use") ||
+            typeof block.name !== "string") {
+            return [];
+        }
+        const key = readTrimmedString(block.id) ??
+            `stream:${block.name}:${typeof event.index === "number" ? event.index : 0}`;
+        return [
+            {
+                key,
+                toolName: block.name,
+                input: block.input ?? null,
+            },
+        ];
+    }
+    extractSubAgentActionCandidates(message) {
+        if (message.type === "assistant") {
+            return this.extractAssistantMessageActions(message);
+        }
+        if (message.type === "stream_event") {
+            return this.extractStreamEventActions(message);
+        }
+        if (message.type === "tool_progress") {
+            const toolName = readTrimmedString(message.tool_name);
+            if (!toolName) {
+                return [];
+            }
+            const key = readTrimmedString(message.tool_use_id) ?? `progress:${toolName}`;
+            return [{ key, toolName, input: null }];
+        }
+        return [];
+    }
+    appendSubAgentAction(state, candidate) {
+        const normalizedToolName = readTrimmedString(candidate.toolName);
+        if (!normalizedToolName) {
+            return false;
+        }
+        const summary = this.deriveSubAgentActionSummary(normalizedToolName, candidate.input);
+        const existingIndex = state.actionIndexByKey.get(candidate.key);
+        if (existingIndex !== undefined) {
+            const existing = state.actions[existingIndex];
+            if (!existing) {
+                return false;
+            }
+            const nextSummary = existing.summary ?? summary;
+            if (existing.toolName === normalizedToolName && existing.summary === nextSummary) {
+                return false;
+            }
+            state.actions[existingIndex] = {
+                ...existing,
+                toolName: normalizedToolName,
+                input: existing.input ?? candidate.input,
+                ...(nextSummary ? { summary: nextSummary } : {}),
+            };
+            return true;
+        }
+        state.actions.push({
+            index: state.nextActionIndex,
+            toolName: normalizedToolName,
+            input: candidate.input,
+            ...(summary ? { summary } : {}),
+        });
+        state.nextActionIndex += 1;
+        state.actionKeys.push(candidate.key);
+        this.trimSubAgentTail(state);
+        this.rebuildSubAgentActionIndex(state);
+        return true;
+    }
+    trimSubAgentTail(state) {
+        while (state.actions.length > MAX_SUB_AGENT_LOG_ENTRIES) {
+            state.actions.shift();
+            const removedKey = state.actionKeys.shift();
+            if (removedKey)
+                state.completedActionKeys.delete(removedKey);
+        }
+    }
+    rebuildSubAgentActionIndex(state) {
+        state.actionIndexByKey.clear();
+        for (let index = 0; index < state.actionKeys.length; index += 1) {
+            const key = state.actionKeys[index];
+            if (key) {
+                state.actionIndexByKey.set(key, index);
+            }
+        }
+    }
+    deriveSubAgentActionSummary(toolName, input) {
+        const runningToolCall = mapClaudeRunningToolCall({
+            name: toolName,
+            callId: `sub-agent-summary-${toolName}`,
+            input,
+            output: null,
+        });
+        if (!runningToolCall) {
+            return undefined;
+        }
+        const display = buildToolCallDisplayModel({
+            name: runningToolCall.name,
+            status: runningToolCall.status,
+            error: runningToolCall.error,
+            detail: runningToolCall.detail,
+            metadata: runningToolCall.metadata,
+        });
+        return this.normalizeSubAgentText(display.summary);
+    }
+}
+//# sourceMappingURL=sidechain-tracker.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/providers/claude/task-notification-tool-call.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import type { AgentTimelineItem } from "../../agent-sdk-types.js";
+declare const TaskNotificationEnvelopeSchema: z.ZodObject<{
+    messageId: z.ZodNullable<z.ZodString>;
+    taskId: z.ZodNullable<z.ZodString>;
+    status: z.ZodNullable<z.ZodString>;
+    summary: z.ZodNullable<z.ZodString>;
+    outputFile: z.ZodNullable<z.ZodString>;
+    rawText: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const MapTaskNotificationUserContentToToolCallInputSchema: z.ZodObject<{
+    content: z.ZodUnknown;
+    messageId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export type TaskNotificationEnvelope = z.infer<typeof TaskNotificationEnvelopeSchema>;
+export type MapTaskNotificationUserContentToToolCallInput = z.infer<typeof MapTaskNotificationUserContentToToolCallInputSchema>;
+export interface TaskNotificationSystemMessageLike {
+    type: "system";
+    subtype: "task_notification";
+    uuid?: string;
+    task_id?: string;
+    status?: "completed" | "failed" | "stopped";
+    summary?: string;
+    output_file?: string;
+    content?: string;
+}
+type TaskNotificationToolCallItem = Extract<AgentTimelineItem, {
+    type: "tool_call";
+}>;
+export declare function isTaskNotificationUserContent(content: unknown): boolean;
+export declare function mapTaskNotificationUserContentToToolCall(input: MapTaskNotificationUserContentToToolCallInput): TaskNotificationToolCallItem | null;
+export declare function mapTaskNotificationSystemRecordToToolCall(record: unknown): TaskNotificationToolCallItem | null;
+export declare function coerceTaskNotificationHistoryRecordToSystemMessage(record: unknown): TaskNotificationSystemMessageLike | null;
+export {};
+//# sourceMappingURL=task-notification-tool-call.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/providers/claude/task-notification-tool-call.js

@@ -0,0 +1,272 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+const TASK_NOTIFICATION_MARKER = "<task-notification>";
+const TAG_NAME_PATTERN = /[.*+?^${}()|[\]\\]/g;
+const OptionalNonEmptyTrimmedStringSchema = z.preprocess((value) => (typeof value === "string" ? value.trim() : value), z.string().min(1).optional());
+const TaskNotificationEnvelopeSchema = z.object({
+    messageId: z.string().nullable(),
+    taskId: z.string().nullable(),
+    status: z.string().nullable(),
+    summary: z.string().nullable(),
+    outputFile: z.string().nullable(),
+    rawText: z.string().nullable(),
+});
+const TaskNotificationUserContentBlockSchema = z
+    .object({
+    text: z.string().optional(),
+    input: z.string().optional(),
+})
+    .passthrough();
+const TaskNotificationUserContentSchema = z.union([
+    z.string(),
+    z.array(TaskNotificationUserContentBlockSchema),
+]);
+const TaskNotificationHistoryRecordSchema = z
+    .object({
+    type: z.string().optional(),
+    subtype: z.string().optional(),
+    uuid: z.string().optional(),
+    message_id: z.string().optional(),
+    task_id: z.string().optional(),
+    status: z.string().optional(),
+    summary: z.string().optional(),
+    output_file: z.string().optional(),
+    content: z.string().optional(),
+})
+    .passthrough();
+const MapTaskNotificationUserContentToToolCallInputSchema = z.object({
+    content: z.unknown(),
+    messageId: z.string().optional().nullable(),
+});
+function toNonEmptyString(value) {
+    const parsed = OptionalNonEmptyTrimmedStringSchema.safeParse(value);
+    if (!parsed.success) {
+        return null;
+    }
+    return parsed.data ?? null;
+}
+function collectUserContentParts(content) {
+    if (typeof content === "string") {
+        const normalized = toNonEmptyString(content);
+        return normalized ? [normalized] : [];
+    }
+    const parts = [];
+    for (const block of content) {
+        const text = toNonEmptyString(block.text);
+        if (text) {
+            parts.push(text);
+        }
+        const input = toNonEmptyString(block.input);
+        if (input) {
+            parts.push(input);
+        }
+    }
+    return parts;
+}
+function extractUserContentText(content) {
+    const parsedContent = TaskNotificationUserContentSchema.safeParse(content);
+    if (!parsedContent.success) {
+        return null;
+    }
+    const parts = collectUserContentParts(parsedContent.data);
+    if (parts.length === 0) {
+        return null;
+    }
+    return parts.join("\n\n");
+}
+function readTaskNotificationTagValue(input) {
+    const escapedTagName = input.tagName.replace(TAG_NAME_PATTERN, "\\$&");
+    const pattern = new RegExp(`<${escapedTagName}>\\s*([\\s\\S]*?)\\s*</${escapedTagName}>`, "i");
+    const match = input.text.match(pattern);
+    if (!match) {
+        return null;
+    }
+    return toNonEmptyString(match[1]);
+}
+function parseTaskNotificationFromUserContent(input) {
+    const parsedInput = MapTaskNotificationUserContentToToolCallInputSchema.safeParse(input);
+    if (!parsedInput.success) {
+        return null;
+    }
+    const rawText = extractUserContentText(parsedInput.data.content);
+    if (!rawText || !rawText.includes(TASK_NOTIFICATION_MARKER)) {
+        return null;
+    }
+    return TaskNotificationEnvelopeSchema.parse({
+        messageId: toNonEmptyString(parsedInput.data.messageId),
+        taskId: readTaskNotificationTagValue({ text: rawText, tagName: "task-id" }),
+        status: readTaskNotificationTagValue({ text: rawText, tagName: "status" }),
+        summary: readTaskNotificationTagValue({ text: rawText, tagName: "summary" }),
+        outputFile: readTaskNotificationTagValue({ text: rawText, tagName: "output-file" }) ??
+            readTaskNotificationTagValue({ text: rawText, tagName: "output_file" }),
+        rawText,
+    });
+}
+function parseTaskNotificationFromSystemRecord(record) {
+    const parsedRecord = TaskNotificationHistoryRecordSchema.safeParse(record);
+    if (!parsedRecord.success) {
+        return null;
+    }
+    const systemRecord = parsedRecord.data;
+    const isSystemTaskNotification = systemRecord.type === "system" && systemRecord.subtype === "task_notification";
+    const isQueueOperation = systemRecord.type === "queue-operation";
+    if (!isSystemTaskNotification && !isQueueOperation) {
+        return null;
+    }
+    const rawText = toNonEmptyString(systemRecord.content);
+    return TaskNotificationEnvelopeSchema.parse({
+        messageId: toNonEmptyString(systemRecord.uuid) ?? toNonEmptyString(systemRecord.message_id),
+        taskId: toNonEmptyString(systemRecord.task_id) ??
+            (rawText ? readTaskNotificationTagValue({ text: rawText, tagName: "task-id" }) : null),
+        status: toNonEmptyString(systemRecord.status) ??
+            (rawText ? readTaskNotificationTagValue({ text: rawText, tagName: "status" }) : null),
+        summary: toNonEmptyString(systemRecord.summary) ??
+            (rawText ? readTaskNotificationTagValue({ text: rawText, tagName: "summary" }) : null),
+        outputFile: toNonEmptyString(systemRecord.output_file) ??
+            (rawText
+                ? (readTaskNotificationTagValue({ text: rawText, tagName: "output-file" }) ??
+                    readTaskNotificationTagValue({ text: rawText, tagName: "output_file" }))
+                : null),
+        rawText,
+    });
+}
+function normalizeTaskNotificationCallIdSegment(segment) {
+    const normalized = segment.trim().replace(/[^a-zA-Z0-9._:-]+/g, "_");
+    return normalized.length > 0 ? normalized : null;
+}
+function buildTaskNotificationCallId(envelope) {
+    const messageSegment = envelope.messageId
+        ? normalizeTaskNotificationCallIdSegment(envelope.messageId)
+        : null;
+    if (messageSegment) {
+        return `task_notification_${messageSegment}`;
+    }
+    const taskSegment = envelope.taskId
+        ? normalizeTaskNotificationCallIdSegment(envelope.taskId)
+        : null;
+    if (taskSegment) {
+        return `task_notification_${taskSegment}`;
+    }
+    const seed = [envelope.status, envelope.summary, envelope.outputFile, envelope.rawText]
+        .filter((value) => typeof value === "string")
+        .join("|") || "task_notification";
+    const digest = createHash("sha1").update(seed).digest("hex").slice(0, 12);
+    return `task_notification_${digest}`;
+}
+function buildTaskNotificationLabel(envelope) {
+    if (envelope.summary) {
+        return envelope.summary;
+    }
+    if (envelope.status) {
+        return `Background task ${envelope.status.toLowerCase()}`;
+    }
+    return "Background task notification";
+}
+function buildTaskNotificationStatus(input) {
+    const normalizedStatus = input.status?.toLowerCase() ?? null;
+    if (normalizedStatus === "failed" || normalizedStatus === "error") {
+        return {
+            status: "failed",
+            error: { message: input.summary ?? "Background task failed" },
+        };
+    }
+    if (normalizedStatus === "canceled" || normalizedStatus === "cancelled") {
+        return { status: "canceled", error: null };
+    }
+    return { status: "completed", error: null };
+}
+function toTaskNotificationToolCall(envelope) {
+    const lifecycle = buildTaskNotificationStatus({
+        status: envelope.status,
+        summary: envelope.summary,
+    });
+    const label = buildTaskNotificationLabel(envelope);
+    const detailText = envelope.rawText ?? envelope.summary ?? undefined;
+    const metadata = {
+        synthetic: true,
+        source: "claude_task_notification",
+        ...(envelope.taskId ? { taskId: envelope.taskId } : {}),
+        ...(envelope.status ? { status: envelope.status } : {}),
+        ...(envelope.outputFile ? { outputFile: envelope.outputFile } : {}),
+    };
+    const base = {
+        type: "tool_call",
+        callId: buildTaskNotificationCallId(envelope),
+        name: "task_notification",
+        detail: {
+            type: "plain_text",
+            label,
+            icon: "wrench",
+            ...(detailText ? { text: detailText } : {}),
+        },
+        metadata,
+    };
+    if (lifecycle.status === "failed") {
+        return {
+            ...base,
+            status: "failed",
+            error: lifecycle.error,
+        };
+    }
+    if (lifecycle.status === "canceled") {
+        return {
+            ...base,
+            status: "canceled",
+            error: null,
+        };
+    }
+    return {
+        ...base,
+        status: "completed",
+        error: null,
+    };
+}
+export function isTaskNotificationUserContent(content) {
+    const rawText = extractUserContentText(content);
+    if (!rawText) {
+        return false;
+    }
+    return rawText.includes(TASK_NOTIFICATION_MARKER);
+}
+export function mapTaskNotificationUserContentToToolCall(input) {
+    const parsed = parseTaskNotificationFromUserContent(input);
+    if (!parsed) {
+        return null;
+    }
+    return toTaskNotificationToolCall(parsed);
+}
+export function mapTaskNotificationSystemRecordToToolCall(record) {
+    const parsed = parseTaskNotificationFromSystemRecord(record);
+    if (!parsed) {
+        return null;
+    }
+    return toTaskNotificationToolCall(parsed);
+}
+export function coerceTaskNotificationHistoryRecordToSystemMessage(record) {
+    const parsed = parseTaskNotificationFromSystemRecord(record);
+    if (!parsed) {
+        return null;
+    }
+    const normalizedStatus = parsed.status?.toLowerCase() ?? null;
+    let status;
+    if (normalizedStatus === "failed" || normalizedStatus === "error") {
+        status = "failed";
+    }
+    else if (normalizedStatus === "canceled" || normalizedStatus === "cancelled") {
+        status = "stopped";
+    }
+    else {
+        status = "completed";
+    }
+    return {
+        type: "system",
+        subtype: "task_notification",
+        ...(parsed.messageId ? { uuid: parsed.messageId } : {}),
+        ...(parsed.taskId ? { task_id: parsed.taskId } : {}),
+        status,
+        ...(parsed.summary ? { summary: parsed.summary } : {}),
+        ...(parsed.outputFile ? { output_file: parsed.outputFile } : {}),
+        ...(parsed.rawText ? { content: parsed.rawText } : {}),
+    };
+}
+//# sourceMappingURL=task-notification-tool-call.js.map