@traceroot-ai/traceroot 0.1.4 → 0.1.6

package/dist/claude-agent-sdk.d.ts

@@ -0,0 +1,2 @@
+export declare function wireClaudeAgentSDKInstrumentation(mod: unknown): void;
+//# sourceMappingURL=claude-agent-sdk.d.ts.map

package/dist/claude-agent-sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-agent-sdk.d.ts","sourceRoot":"","sources":["../src/claude-agent-sdk.ts"],"names":[],"mappings":"AAm1BA,wBAAgB,iCAAiC,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAgBpE"}

package/dist/claude-agent-sdk.js

@@ -0,0 +1,678 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wireClaudeAgentSDKInstrumentation = wireClaudeAgentSDKInstrumentation;
+const api_1 = require("@opentelemetry/api");
+const constants_1 = require("./constants");
+// Use the global symbol registry so duplicated package copies still avoid double wrapping.
+const WRAPPED = Symbol.for('traceroot.claude_agent_sdk.wrapped');
+const ROOT_LLM_PARENT_KEY = '__root__';
+const LLM_SPAN_NAME = 'anthropic.messages.create';
+const QUERY_SPAN_NAME = 'ClaudeAgent.query';
+const OI_SPAN_KIND_VALUE = {
+    AGENT: 'AGENT',
+    LLM: 'LLM',
+    TOOL: 'TOOL',
+};
+const LLM_TOKEN_ATTRIBUTES = {
+    TOTAL: 'llm.token_count.total',
+    CACHE_READ: 'llm.token_count.prompt_details.cache_read',
+    CACHE_CREATION: 'llm.token_count.prompt_details.cache_creation',
+};
+const GEN_AI_ATTRIBUTES = {
+    RESPONSE_MODEL: 'gen_ai.response.model',
+    TOOL_CALL_ID: 'gen_ai.tool.call.id',
+    TOOL_NAME: 'gen_ai.tool.name',
+};
+const CLAUDE_AGENT_ATTRIBUTES = {
+    AGENT_ID: 'claude_agent_sdk.agent_id',
+    AGENT_TYPE: 'claude_agent_sdk.agent_type',
+    CWD: 'claude_agent_sdk.cwd',
+    DURATION_MS: 'claude_agent_sdk.duration_ms',
+    MODEL: 'claude_agent_sdk.model',
+    NUM_TURNS: 'claude_agent_sdk.num_turns',
+    TOOL_USE_COUNT: 'claude_agent_sdk.tool_use_count',
+    TOOL_USE_ID: 'claude_agent_sdk.tool_use_id',
+    TOTAL_COST_USD: 'claude_agent_sdk.total_cost_usd',
+};
+function tryStringify(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function setJsonAttribute(span, key, value) {
+    const serialized = tryStringify(value);
+    if (serialized !== undefined)
+        span.setAttribute(key, serialized);
+}
+function getToolUseId(input, toolUseId) {
+    return toolUseId ?? (typeof input.tool_use_id === 'string' ? input.tool_use_id : undefined);
+}
+function getString(input, key) {
+    const value = input[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function getNumber(input, key) {
+    const value = input[key];
+    return typeof value === 'number' ? value : undefined;
+}
+function getUsage(message) {
+    return message.message?.usage ?? message.usage;
+}
+function setUsageAttributes(span, usage) {
+    if (!usage)
+        return;
+    const cacheRead = usage.cache_read_input_tokens ?? 0;
+    const cacheCreation = usage.cache_creation_input_tokens ?? 0;
+    const prompt = (usage.input_tokens ?? 0) + cacheRead + cacheCreation;
+    const completion = usage.output_tokens ?? 0;
+    if (prompt > 0)
+        span.setAttribute(constants_1.OI_LLM_TOKEN_COUNT_PROMPT, prompt);
+    if (completion > 0)
+        span.setAttribute(constants_1.OI_LLM_TOKEN_COUNT_COMPLETION, completion);
+    if (prompt > 0 || completion > 0) {
+        span.setAttribute(LLM_TOKEN_ATTRIBUTES.TOTAL, prompt + completion);
+    }
+    if (cacheRead > 0) {
+        span.setAttribute(LLM_TOKEN_ATTRIBUTES.CACHE_READ, cacheRead);
+    }
+    if (cacheCreation > 0) {
+        span.setAttribute(LLM_TOKEN_ATTRIBUTES.CACHE_CREATION, cacheCreation);
+    }
+}
+function setCommonModel(span, model) {
+    if (!model)
+        return;
+    span.setAttribute(constants_1.OI_LLM_MODEL_NAME, model);
+    span.setAttribute(GEN_AI_ATTRIBUTES.RESPONSE_MODEL, model);
+}
+function getMessageModel(message, options) {
+    return message.message?.model ?? options?.model;
+}
+function llmParentKey(parentToolUseId) {
+    return parentToolUseId ?? ROOT_LLM_PARENT_KEY;
+}
+function isTaskSiblingTool(toolName) {
+    return toolName === 'Agent' || toolName === 'Task' || toolName === 'Bash';
+}
+function getParentToolUseIdForTool(state, toolUseId, input) {
+    if (state.toolUseToParent.has(toolUseId)) {
+        return state.toolUseToParent.get(toolUseId) ?? null;
+    }
+    const agentId = getString(input, 'agent_id');
+    if (!agentId)
+        return null;
+    return state.agentIdToToolUseId.get(agentId) ?? null;
+}
+function getToolParentContext(state, input) {
+    const agentId = getString(input, 'agent_id');
+    const subagentToolUseId = agentId ? state.agentIdToToolUseId.get(agentId) : undefined;
+    const subagent = subagentToolUseId ? state.subagents.get(subagentToolUseId) : undefined;
+    return subagent?.ctx ?? state.ctx;
+}
+function getTaskParentContext(state, parentToolUseId) {
+    if (parentToolUseId) {
+        return state.subagents.get(parentToolUseId)?.ctx ?? state.ctx;
+    }
+    return state.ctx;
+}
+function ensureActiveLLMSpan(state, parentToolUseId, startTime) {
+    const parentKey = llmParentKey(parentToolUseId);
+    const existing = state.activeLLMSpansByParent.get(parentKey);
+    if (existing)
+        return existing;
+    const parentCtx = getTaskParentContext(state, parentToolUseId);
+    const span = state.tracer.startSpan(LLM_SPAN_NAME, {
+        attributes: {
+            [constants_1.OI_SPAN_KIND]: OI_SPAN_KIND_VALUE.LLM,
+        },
+        startTime,
+    }, parentCtx);
+    const llm = { ctx: api_1.trace.setSpan(parentCtx, span), span };
+    state.activeLLMSpansByParent.set(parentKey, llm);
+    return llm;
+}
+function resolveToolParentContext(state, toolUseId, toolName, input) {
+    const parentToolUseId = getParentToolUseIdForTool(state, toolUseId, input);
+    if (isTaskSiblingTool(toolName)) {
+        return getTaskParentContext(state, parentToolUseId);
+    }
+    const parentKey = llmParentKey(parentToolUseId);
+    const activeLLM = state.activeLLMSpansByParent.get(parentKey);
+    // Claude hook events can arrive before the assistant message that creates the
+    // LLM turn span. In that case, keep the tool under the task/subagent context.
+    return activeLLM?.ctx ?? getToolParentContext(state, input);
+}
+function findActiveAgentToolUseId(state) {
+    for (const tool of state.tools.values()) {
+        if (tool.name === 'Agent' && !tool.hasSubagent)
+            return tool.toolUseId;
+    }
+    return undefined;
+}
+function canonicalSubagentToolUseId(state, rawToolUseId, input) {
+    const existing = state.rawSubagentToolUseIdToToolUseId.get(rawToolUseId);
+    if (existing)
+        return existing;
+    if (state.tools.has(rawToolUseId)) {
+        state.rawSubagentToolUseIdToToolUseId.set(rawToolUseId, rawToolUseId);
+        return rawToolUseId;
+    }
+    const agentId = input ? getString(input, 'agent_id') : undefined;
+    const agentToolUseId = agentId ? state.agentIdToToolUseId.get(agentId) : undefined;
+    if (agentToolUseId) {
+        state.rawSubagentToolUseIdToToolUseId.set(rawToolUseId, agentToolUseId);
+        return agentToolUseId;
+    }
+    const activeAgentToolUseId = findActiveAgentToolUseId(state);
+    if (activeAgentToolUseId) {
+        state.rawSubagentToolUseIdToToolUseId.set(rawToolUseId, activeAgentToolUseId);
+        return activeAgentToolUseId;
+    }
+    state.rawSubagentToolUseIdToToolUseId.set(rawToolUseId, rawToolUseId);
+    return rawToolUseId;
+}
+function ensureSubagent(state, toolUseId, input) {
+    const existing = state.subagents.get(toolUseId);
+    if (existing)
+        return existing;
+    const toolState = state.tools.get(toolUseId);
+    if (toolState)
+        toolState.hasSubagent = true;
+    const parentCtx = toolState?.ctx ?? state.ctx;
+    const span = state.tracer.startSpan('Subagent', {
+        attributes: {
+            [constants_1.OI_SPAN_KIND]: OI_SPAN_KIND_VALUE.AGENT,
+            ...(input && getString(input, 'agent_type')
+                ? { [CLAUDE_AGENT_ATTRIBUTES.AGENT_TYPE]: getString(input, 'agent_type') }
+                : {}),
+            [CLAUDE_AGENT_ATTRIBUTES.TOOL_USE_ID]: toolUseId,
+        },
+    }, parentCtx);
+    const stateEntry = {
+        agentId: input ? getString(input, 'agent_id') : undefined,
+        ctx: api_1.trace.setSpan(parentCtx, span),
+        span,
+        toolUseId,
+    };
+    state.subagents.set(toolUseId, stateEntry);
+    if (stateEntry.agentId)
+        state.agentIdToToolUseId.set(stateEntry.agentId, toolUseId);
+    return stateEntry;
+}
+function cleanupToolUseMappings(state, rawToolUseId, toolUseId) {
+    state.toolUseToParent.delete(rawToolUseId);
+    state.toolUseToParent.delete(toolUseId);
+    state.rawSubagentToolUseIdToToolUseId.delete(rawToolUseId);
+}
+function cleanupSubagentMappings(state, subagent) {
+    if (subagent.agentId)
+        state.agentIdToToolUseId.delete(subagent.agentId);
+}
+function createTracingHooks(state) {
+    const preToolUse = async (input, toolUseIdArg) => {
+        if (input.hook_event_name !== 'PreToolUse')
+            return {};
+        const now = new Date();
+        const toolUseId = getToolUseId(input, toolUseIdArg);
+        const toolName = getString(input, 'tool_name');
+        if (!toolUseId || !toolName)
+            return {};
+        const startTime = now;
+        const parentCtx = resolveToolParentContext(state, toolUseId, toolName, input);
+        const span = state.tracer.startSpan(toolName, {
+            attributes: {
+                [constants_1.OI_SPAN_KIND]: OI_SPAN_KIND_VALUE.TOOL,
+                [constants_1.TOOL_NAME]: toolName,
+                [GEN_AI_ATTRIBUTES.TOOL_NAME]: toolName,
+                [GEN_AI_ATTRIBUTES.TOOL_CALL_ID]: toolUseId,
+                ...(getString(input, 'cwd')
+                    ? { [CLAUDE_AGENT_ATTRIBUTES.CWD]: getString(input, 'cwd') }
+                    : {}),
+                ...(getString(input, 'session_id')
+                    ? { [constants_1.OI_TRACE_SESSION_ID]: getString(input, 'session_id') }
+                    : {}),
+            },
+            startTime,
+        }, parentCtx);
+        setJsonAttribute(span, constants_1.OI_INPUT_VALUE, input.tool_input);
+        state.tools.set(toolUseId, {
+            ctx: api_1.trace.setSpan(parentCtx, span),
+            hasSubagent: false,
+            name: toolName,
+            span,
+            toolUseId,
+        });
+        return {};
+    };
+    const postToolUse = async (input, toolUseIdArg) => {
+        if (input.hook_event_name !== 'PostToolUse')
+            return {};
+        const now = new Date();
+        const rawToolUseId = getToolUseId(input, toolUseIdArg);
+        if (!rawToolUseId)
+            return {};
+        const toolUseId = state.tools.has(rawToolUseId)
+            ? rawToolUseId
+            : canonicalSubagentToolUseId(state, rawToolUseId, input);
+        const tool = state.tools.get(toolUseId);
+        if (tool) {
+            setJsonAttribute(tool.span, constants_1.OI_OUTPUT_VALUE, input.tool_response);
+            tool.span.setStatus({ code: api_1.SpanStatusCode.OK });
+            tool.span.end(now);
+            state.tools.delete(toolUseId);
+            cleanupToolUseMappings(state, rawToolUseId, toolUseId);
+        }
+        const subagent = state.subagents.get(toolUseId);
+        const response = input.tool_response;
+        if (subagent && !subagent.ended && response && typeof response === 'object') {
+            const record = response;
+            const agentType = getString(record, 'agentType');
+            if (agentType)
+                subagent.span.setAttribute(CLAUDE_AGENT_ATTRIBUTES.AGENT_TYPE, agentType);
+            const agentId = getString(record, 'agentId');
+            if (agentId)
+                subagent.span.setAttribute(CLAUDE_AGENT_ATTRIBUTES.AGENT_ID, agentId);
+            const durationMs = getNumber(record, 'totalDurationMs');
+            if (durationMs !== undefined)
+                subagent.span.setAttribute(CLAUDE_AGENT_ATTRIBUTES.DURATION_MS, durationMs);
+            const toolUseCount = getNumber(record, 'totalToolUseCount');
+            if (toolUseCount !== undefined) {
+                subagent.span.setAttribute(CLAUDE_AGENT_ATTRIBUTES.TOOL_USE_COUNT, toolUseCount);
+            }
+            setJsonAttribute(subagent.span, constants_1.OI_OUTPUT_VALUE, record.content);
+            subagent.span.setStatus({ code: api_1.SpanStatusCode.OK });
+            subagent.span.end(now);
+            subagent.ended = true;
+            cleanupSubagentMappings(state, subagent);
+        }
+        return {};
+    };
+    const postToolUseFailure = async (input, toolUseIdArg) => {
+        if (input.hook_event_name !== 'PostToolUseFailure')
+            return {};
+        const now = new Date();
+        const rawToolUseId = getToolUseId(input, toolUseIdArg);
+        if (!rawToolUseId)
+            return {};
+        const toolUseId = state.tools.has(rawToolUseId)
+            ? rawToolUseId
+            : canonicalSubagentToolUseId(state, rawToolUseId, input);
+        const error = getString(input, 'error') ?? 'Tool failed';
+        const tool = state.tools.get(toolUseId);
+        if (tool) {
+            tool.span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error });
+            tool.span.recordException(new Error(error));
+            tool.span.end(now);
+            state.tools.delete(toolUseId);
+            cleanupToolUseMappings(state, rawToolUseId, toolUseId);
+        }
+        const subagent = state.subagents.get(toolUseId);
+        if (subagent && !subagent.ended) {
+            subagent.span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error });
+            subagent.span.recordException(new Error(error));
+            subagent.span.end(now);
+            subagent.ended = true;
+            cleanupSubagentMappings(state, subagent);
+        }
+        return {};
+    };
+    const subagentStart = async (input, toolUseIdArg) => {
+        if (input.hook_event_name !== 'SubagentStart')
+            return {};
+        const rawToolUseId = getToolUseId(input, toolUseIdArg);
+        if (!rawToolUseId)
+            return {};
+        const toolUseId = canonicalSubagentToolUseId(state, rawToolUseId, input);
+        const subagent = ensureSubagent(state, toolUseId, input);
+        const agentId = getString(input, 'agent_id');
+        if (agentId) {
+            subagent.agentId = agentId;
+            state.agentIdToToolUseId.set(agentId, toolUseId);
+            subagent.span.setAttribute(CLAUDE_AGENT_ATTRIBUTES.AGENT_ID, agentId);
+        }
+        const agentType = getString(input, 'agent_type');
+        if (agentType)
+            subagent.span.setAttribute(CLAUDE_AGENT_ATTRIBUTES.AGENT_TYPE, agentType);
+        return {};
+    };
+    const subagentStop = async (input, toolUseIdArg) => {
+        if (input.hook_event_name !== 'SubagentStop')
+            return {};
+        const now = new Date();
+        const rawToolUseId = getToolUseId(input, toolUseIdArg);
+        if (!rawToolUseId)
+            return {};
+        const toolUseId = canonicalSubagentToolUseId(state, rawToolUseId, input);
+        const subagent = state.subagents.get(toolUseId);
+        if (!subagent || subagent.ended)
+            return {};
+        const output = input.last_assistant_message;
+        if (output !== undefined)
+            setJsonAttribute(subagent.span, constants_1.OI_OUTPUT_VALUE, output);
+        subagent.span.setStatus({ code: api_1.SpanStatusCode.OK });
+        subagent.span.end(now);
+        subagent.ended = true;
+        cleanupSubagentMappings(state, subagent);
+        return {};
+    };
+    return {
+        PostToolUse: [{ hooks: [postToolUse] }],
+        PostToolUseFailure: [{ hooks: [postToolUseFailure] }],
+        PreToolUse: [{ hooks: [preToolUse] }],
+        SubagentStart: [{ hooks: [subagentStart] }],
+        SubagentStop: [{ hooks: [subagentStop] }],
+    };
+}
+function mergeHooks(options, hooks) {
+    const existing = options?.hooks ?? {};
+    const merged = { ...existing };
+    for (const [event, matchers] of Object.entries(hooks)) {
+        merged[event] = [...(existing[event] ?? []), ...matchers];
+    }
+    return { ...(options ?? {}), hooks: merged };
+}
+function trackToolUseContext(state, message) {
+    if (message.type !== 'assistant' || !Array.isArray(message.message?.content))
+        return;
+    const parentToolUseId = message.parent_tool_use_id ?? null;
+    for (const block of message.message.content) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const record = block;
+        if (record.type !== 'tool_use' || typeof record.id !== 'string')
+            continue;
+        state.toolUseToParent.set(record.id, parentToolUseId);
+    }
+}
+function emitLLMSpan(state, messages, endTime) {
+    if (messages.length === 0)
+        return;
+    const firstMessage = messages[0];
+    const lastMessage = messages[messages.length - 1];
+    if (firstMessage.type !== 'assistant' || !lastMessage.message)
+        return;
+    const parentToolUseId = firstMessage.parent_tool_use_id ?? null;
+    const parentKey = llmParentKey(parentToolUseId);
+    const activeLLM = ensureActiveLLMSpan(state, parentToolUseId, state.currentMessageStartTime);
+    const model = getMessageModel(lastMessage, state.params.options);
+    const span = activeLLM.span;
+    setCommonModel(span, model);
+    setUsageAttributes(span, getUsage(lastMessage));
+    if (!firstMessage.parent_tool_use_id) {
+        if (typeof state.params.prompt === 'string') {
+            setJsonAttribute(span, constants_1.OI_INPUT_VALUE, [{ role: 'user', content: state.params.prompt }]);
+        }
+    }
+    const output = messages
+        .map((message) => message.message?.content !== undefined || message.message?.role !== undefined
+        ? {
+            role: message.message?.role ?? 'assistant',
+            content: message.message?.content,
+        }
+        : undefined)
+        .filter((message) => message !== undefined);
+    if (output.length > 0) {
+        setJsonAttribute(span, constants_1.OI_OUTPUT_VALUE, output);
+    }
+    span.setStatus({ code: api_1.SpanStatusCode.OK });
+    span.end(endTime);
+    state.activeLLMSpansByParent.delete(parentKey);
+    state.accumulatedOutputTokens += getUsage(lastMessage)?.output_tokens ?? 0;
+    state.currentMessageStartTime = endTime;
+}
+function flushPendingLLMSpan(state, endTime = new Date()) {
+    if (state.pendingAssistantMessages.length === 0)
+        return;
+    emitLLMSpan(state, state.pendingAssistantMessages, endTime);
+    state.pendingAssistantMessages = [];
+}
+function shouldFlushBeforeAssistantMessage(state, message) {
+    const pending = state.pendingAssistantMessages;
+    if (pending.length === 0)
+        return false;
+    const first = pending[0];
+    const nextMessageId = message.message?.id;
+    if (nextMessageId && nextMessageId !== state.currentMessageId)
+        return true;
+    return (first.parent_tool_use_id !== message.parent_tool_use_id ||
+        getMessageModel(first, state.params.options) !== getMessageModel(message, state.params.options));
+}
+function updateCurrentMessageId(state, message) {
+    const messageId = message.message?.id;
+    if (messageId)
+        state.currentMessageId = messageId;
+}
+function adjustPendingAssistantUsageFromResult(state, resultMessage) {
+    if (state.pendingAssistantMessages.length === 0)
+        return;
+    const finalUsage = getUsage(resultMessage);
+    if (!finalUsage)
+        return;
+    const finalOutputTokens = finalUsage?.output_tokens;
+    if (finalOutputTokens === undefined)
+        return;
+    const lastMessage = state.pendingAssistantMessages[state.pendingAssistantMessages.length - 1];
+    const lastUsage = lastMessage?.message?.usage;
+    if (!lastUsage)
+        return;
+    const remainingOutputTokens = finalOutputTokens - state.accumulatedOutputTokens;
+    if (remainingOutputTokens >= 0) {
+        lastUsage.output_tokens = remainingOutputTokens;
+    }
+    if (finalUsage.cache_read_input_tokens !== undefined) {
+        lastUsage.cache_read_input_tokens = finalUsage.cache_read_input_tokens;
+    }
+    if (finalUsage.cache_creation_input_tokens !== undefined) {
+        lastUsage.cache_creation_input_tokens = finalUsage.cache_creation_input_tokens;
+    }
+}
+function processMessage(state, message, params) {
+    trackToolUseContext(state, message);
+    if (message.type === 'system' && message.subtype === 'init') {
+        const model = typeof message.model === 'string' ? message.model : params.options?.model;
+        if (model)
+            state.querySpan.setAttribute(CLAUDE_AGENT_ATTRIBUTES.MODEL, model);
+        if (typeof message.session_id === 'string') {
+            state.querySpan.setAttribute(constants_1.OI_TRACE_SESSION_ID, message.session_id);
+        }
+        return;
+    }
+    if (message.type === 'assistant') {
+        const now = new Date();
+        const messageId = message.message?.id;
+        if (messageId && messageId !== state.currentMessageId) {
+            flushPendingLLMSpan(state, now);
+            state.currentMessageId = messageId;
+            state.currentMessageStartTime = now;
+        }
+        else if (shouldFlushBeforeAssistantMessage(state, message)) {
+            flushPendingLLMSpan(state, now);
+            updateCurrentMessageId(state, message);
+        }
+        else {
+            updateCurrentMessageId(state, message);
+        }
+        if (message.message?.usage) {
+            ensureActiveLLMSpan(state, message.parent_tool_use_id ?? null, state.currentMessageStartTime);
+        }
+        state.pendingAssistantMessages.push(message);
+        return;
+    }
+    if (message.type === 'result') {
+        const now = new Date();
+        adjustPendingAssistantUsageFromResult(state, message);
+        flushPendingLLMSpan(state, now);
+        if (typeof message.result === 'string') {
+            state.querySpan.setAttribute(constants_1.OI_OUTPUT_VALUE, message.result);
+        }
+        if (typeof message.session_id === 'string') {
+            state.querySpan.setAttribute(constants_1.OI_TRACE_SESSION_ID, message.session_id);
+        }
+        if (typeof message.num_turns === 'number') {
+            state.querySpan.setAttribute(CLAUDE_AGENT_ATTRIBUTES.NUM_TURNS, message.num_turns);
+        }
+        if (typeof message.total_cost_usd === 'number') {
+            state.querySpan.setAttribute(CLAUDE_AGENT_ATTRIBUTES.TOTAL_COST_USD, message.total_cost_usd);
+        }
+    }
+}
+function endInFlight(state, status) {
+    const now = new Date();
+    flushPendingLLMSpan(state, now);
+    for (const tool of state.tools.values()) {
+        if (status)
+            tool.span.setStatus(status);
+        tool.span.end(now);
+    }
+    state.tools.clear();
+    for (const subagent of state.subagents.values()) {
+        if (!subagent.ended) {
+            if (status)
+                subagent.span.setStatus(status);
+            subagent.span.end(now);
+            subagent.ended = true;
+        }
+    }
+    state.subagents.clear();
+    state.activeLLMSpansByParent.clear();
+    state.agentIdToToolUseId.clear();
+    state.rawSubagentToolUseIdToToolUseId.clear();
+    state.toolUseToParent.clear();
+}
+function wrapQuery(original) {
+    const tracer = api_1.trace.getTracer('@traceroot-ai/claude-agent-sdk');
+    return function wrappedQuery(params) {
+        const parentCtx = api_1.context.active();
+        return {
+            [Symbol.asyncIterator]() {
+                const querySpan = tracer.startSpan(QUERY_SPAN_NAME, {
+                    attributes: {
+                        [constants_1.OI_SPAN_KIND]: OI_SPAN_KIND_VALUE.AGENT,
+                        ...(params.options?.model
+                            ? { [CLAUDE_AGENT_ATTRIBUTES.MODEL]: params.options.model }
+                            : {}),
+                    },
+                }, parentCtx);
+                if (typeof params.prompt === 'string')
+                    querySpan.setAttribute(constants_1.OI_INPUT_VALUE, params.prompt);
+                const state = {
+                    accumulatedOutputTokens: 0,
+                    activeLLMSpansByParent: new Map(),
+                    agentIdToToolUseId: new Map(),
+                    currentMessageStartTime: new Date(),
+                    ctx: api_1.trace.setSpan(parentCtx, querySpan),
+                    params,
+                    pendingAssistantMessages: [],
+                    querySpan,
+                    rawSubagentToolUseIdToToolUseId: new Map(),
+                    subagents: new Map(),
+                    toolUseToParent: new Map(),
+                    tools: new Map(),
+                    tracer,
+                };
+                const modifiedParams = {
+                    ...params,
+                    options: mergeHooks(params.options, createTracingHooks(state)),
+                };
+                let finished = false;
+                const finish = (status = { code: api_1.SpanStatusCode.OK }, error) => {
+                    if (finished)
+                        return;
+                    finished = true;
+                    endInFlight(state, status);
+                    if (error !== undefined) {
+                        querySpan.recordException(error instanceof Error ? error : new Error(String(error)));
+                    }
+                    querySpan.setStatus(status);
+                    querySpan.end();
+                };
+                let inner;
+                try {
+                    inner = original(modifiedParams)[Symbol.asyncIterator]();
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    finish({ code: api_1.SpanStatusCode.ERROR, message }, error);
+                    throw error;
+                }
+                return {
+                    async next() {
+                        try {
+                            const result = await api_1.context.with(state.ctx, () => inner.next());
+                            if (!result.done) {
+                                processMessage(state, result.value, params);
+                            }
+                            else {
+                                finish();
+                            }
+                            return result;
+                        }
+                        catch (error) {
+                            const message = error instanceof Error ? error.message : String(error);
+                            finish({ code: api_1.SpanStatusCode.ERROR, message }, error);
+                            throw error;
+                        }
+                    },
+                    async return(value) {
+                        if (finished)
+                            return { done: true, value: undefined };
+                        try {
+                            const result = inner.return
+                                ? await inner.return(value)
+                                : { done: true, value: undefined };
+                            finish();
+                            return result;
+                        }
+                        catch (error) {
+                            const message = error instanceof Error ? error.message : String(error);
+                            finish({ code: api_1.SpanStatusCode.ERROR, message }, error);
+                            throw error;
+                        }
+                    },
+                    async throw(error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        if (finished)
+                            throw error;
+                        try {
+                            if (inner.throw) {
+                                const result = await inner.throw(error);
+                                finish({ code: api_1.SpanStatusCode.ERROR, message }, error);
+                                return result;
+                            }
+                            finish({ code: api_1.SpanStatusCode.ERROR, message }, error);
+                            throw error;
+                        }
+                        catch (thrown) {
+                            const thrownMessage = thrown instanceof Error ? thrown.message : String(thrown);
+                            finish({ code: api_1.SpanStatusCode.ERROR, message: thrownMessage }, thrown);
+                            throw thrown;
+                        }
+                    },
+                };
+            },
+        };
+    };
+}
+function wireClaudeAgentSDKInstrumentation(mod) {
+    const sdk = mod;
+    if (!sdk || typeof sdk !== 'object' || typeof sdk.query !== 'function') {
+        throw new Error('[TraceRoot] instrumentModules.claudeAgentSDK does not expose query. ' +
+            'Pass a mutable module namespace, e.g. `{ ...claudeAgentSDK }`.');
+    }
+    if (sdk[WRAPPED])
+        return;
+    sdk.query = wrapQuery(sdk.query);
+    Object.defineProperty(sdk, WRAPPED, {
+        configurable: false,
+        enumerable: false,
+        value: true,
+    });
+}
+//# sourceMappingURL=claude-agent-sdk.js.map