@senad-d/observme 0.1.4 → 0.1.6

package/src/pi/event-handlers/session-events.ts

@@ -1,4 +1,11 @@
 import { SpanStatusCode } from "@opentelemetry/api";
+import type {
+  ExtensionContext,
+  SessionBeforeTreeEvent,
+  SessionCompactEvent,
+  SessionInfoChangedEvent,
+  SessionTreeEvent,
+} from "@earendil-works/pi-coding-agent";
 import { COMPACTION_ATTRIBUTES, SESSION_ATTRIBUTES } from "../../semconv/attributes.ts";
 import { LOG_EVENT_NAMES } from "../../semconv/metrics.ts";
 import { SPAN_NAMES } from "../../semconv/spans.ts";
@@ -6,12 +13,14 @@ import {
   buildBranchAttributes,
   buildBranchPreparationState,
   buildCompactionAttributes,
+  buildLineageMetricSafeLogAttributes,
   buildModelChangeAttributes,
   buildThinkingLevelChangeAttributes,
   emitStructuredLog,
   endActiveSpan,
   metricLabels,
   modelChangeMetricLabels,
+  readString,
   resolveOperationParentSpan,
   startActiveChildSpan,
   thinkingLevelChangeMetricLabels,
@@ -20,27 +29,52 @@ import {
 import type { HandlerRegistrar } from "../handler-runtime.ts";
 import type {
   AttributeMap,
-  Handler,
   HandlerSessionState,
-  ObservMeHandlerContext,
   ObservMeTelemetrySession,
+  PiEvent,
+  PiHandler,
 } from "../handler-types.ts";
 
 export function registerSessionEventHandlers(registrar: HandlerRegistrar, state: HandlerSessionState): void {
+  registrar.add("session_info_changed", createSessionInfoChangedHandler(state));
   registrar.add("model_select", createModelChangeHandler(state));
-  registrar.add("model_change", createModelChangeHandler(state));
   registrar.add("thinking_level_select", createThinkingLevelChangeHandler(state));
-  registrar.add("thinking_level_change", createThinkingLevelChangeHandler(state));
   registrar.add("session_before_tree", createSessionBeforeTreeHandler(state));
   registrar.add("session_tree", createBranchHandler(state));
   registrar.add("session_compact", createCompactionHandler(state));
 }
 
-function createModelChangeHandler(state: HandlerSessionState): Handler {
+function createSessionInfoChangedHandler(state: HandlerSessionState): PiHandler<"session_info_changed"> {
+  return handleSessionInfoChanged.bind(undefined, state);
+}
+
+function handleSessionInfoChanged(
+  state: HandlerSessionState,
+  event: SessionInfoChangedEvent,
+  ctx: ExtensionContext,
+): void {
+  const session = state.session;
+  if (!session) return;
+
+  const attributes = {
+    ...buildLineageMetricSafeLogAttributes(session),
+    [SESSION_ATTRIBUTES.PI_SESSION_NAME]: readString(event, "name") ?? ctx.sessionManager?.getSessionName() ?? "unknown",
+  };
+
+  updateCurrentSessionAttributes(session, attributes, [SESSION_ATTRIBUTES.PI_SESSION_NAME]);
+  session.sessionSpan?.addEvent(LOG_EVENT_NAMES.SESSION_NAMED, attributes);
+  emitStructuredLog(session.logger, LOG_EVENT_NAMES.SESSION_NAMED, "session", attributes);
+}
+
+function createModelChangeHandler(state: HandlerSessionState): PiHandler<"model_select"> {
   return handleModelChange.bind(undefined, state);
 }
 
-function handleModelChange(state: HandlerSessionState, event: unknown, ctx: ObservMeHandlerContext): void {
+function handleModelChange(
+  state: HandlerSessionState,
+  event: PiEvent<"model_select">,
+  ctx: ExtensionContext,
+): void {
   const session = state.session;
   if (!session) return;
 
@@ -55,19 +89,19 @@ function handleModelChange(state: HandlerSessionState, event: unknown, ctx: Obse
   emitStructuredLog(session.logger, LOG_EVENT_NAMES.MODEL_CHANGED, "model", attributes);
 }
 
-function createThinkingLevelChangeHandler(state: HandlerSessionState): Handler {
+function createThinkingLevelChangeHandler(state: HandlerSessionState): PiHandler<"thinking_level_select"> {
   return handleThinkingLevelChange.bind(undefined, state);
 }
 
 function handleThinkingLevelChange(
   state: HandlerSessionState,
-  event: unknown,
-  ctx: ObservMeHandlerContext,
+  event: PiEvent<"thinking_level_select">,
+  _ctx: ExtensionContext,
 ): void {
   const session = state.session;
   if (!session) return;
 
-  const attributes = buildThinkingLevelChangeAttributes(event, ctx, session);
+  const attributes = buildThinkingLevelChangeAttributes(event, session);
 
   updateCurrentSessionAttributes(session, attributes, [SESSION_ATTRIBUTES.PI_THINKING_LEVEL_CURRENT]);
   session.metrics.thinkingLevelChanges.add(1, thinkingLevelChangeMetricLabels(session));
@@ -75,14 +109,14 @@ function handleThinkingLevelChange(
   emitStructuredLog(session.logger, LOG_EVENT_NAMES.THINKING_CHANGED, "thinking", attributes);
 }
 
-function createSessionBeforeTreeHandler(state: HandlerSessionState): Handler {
+function createSessionBeforeTreeHandler(state: HandlerSessionState): PiHandler<"session_before_tree"> {
   return handleSessionBeforeTree.bind(undefined, state);
 }
 
 function handleSessionBeforeTree(
   state: HandlerSessionState,
-  event: unknown,
-  _ctx: ObservMeHandlerContext,
+  event: SessionBeforeTreeEvent,
+  _ctx: ExtensionContext,
 ): void {
   const session = state.session;
   if (!session) return;
@@ -90,11 +124,11 @@ function handleSessionBeforeTree(
   session.currentBranchPreparation = buildBranchPreparationState(event, session.config);
 }
 
-function createBranchHandler(state: HandlerSessionState): Handler {
+function createBranchHandler(state: HandlerSessionState): PiHandler<"session_tree"> {
   return handleBranch.bind(undefined, state);
 }
 
-function handleBranch(state: HandlerSessionState, event: unknown, _ctx: ObservMeHandlerContext): void {
+function handleBranch(state: HandlerSessionState, event: SessionTreeEvent, _ctx: ExtensionContext): void {
   const session = state.session;
   if (!session) return;
 
@@ -105,7 +139,7 @@ function handleBranch(state: HandlerSessionState, event: unknown, _ctx: ObservMe
   }
 }
 
-function recordBranch(session: ObservMeTelemetrySession, event: unknown): void {
+function recordBranch(session: ObservMeTelemetrySession, event: SessionTreeEvent): void {
   const attributes = buildBranchAttributes(event, session);
   const labels = metricLabels(session.config, session.lineage);
   const span = startActiveChildSpan(session, SPAN_NAMES.PI_BRANCH, resolveOperationParentSpan(session), attributes, "branch");
@@ -117,18 +151,18 @@ function recordBranch(session: ObservMeTelemetrySession, event: unknown): void {
   emitStructuredLog(session.logger, LOG_EVENT_NAMES.BRANCH_CREATED, "branch", attributes);
 }
 
-function createCompactionHandler(state: HandlerSessionState): Handler {
+function createCompactionHandler(state: HandlerSessionState): PiHandler<"session_compact"> {
   return handleCompaction.bind(undefined, state);
 }
 
-function handleCompaction(state: HandlerSessionState, event: unknown, _ctx: ObservMeHandlerContext): void {
+function handleCompaction(state: HandlerSessionState, event: SessionCompactEvent, _ctx: ExtensionContext): void {
   const session = state.session;
   if (!session) return;
 
   recordCompaction(session, event);
 }
 
-function recordCompaction(session: ObservMeTelemetrySession, event: unknown): void {
+function recordCompaction(session: ObservMeTelemetrySession, event: SessionCompactEvent): void {
   const attributes = buildCompactionAttributes(event, session);
   const labels = metricLabels(session.config, session.lineage);
   const span = startActiveChildSpan(

package/src/pi/event-handlers/tool-bash.ts

@@ -1,4 +1,10 @@
 import { SpanStatusCode } from "@opentelemetry/api";
+import type {
+  ExtensionContext,
+  ToolCallEvent,
+  ToolResultEvent,
+  UserBashEvent,
+} from "@earendil-works/pi-coding-agent";
 import { TOOL_ATTRIBUTES } from "../../semconv/attributes.ts";
 import { LOG_EVENT_NAMES } from "../../semconv/metrics.ts";
 import { SPAN_NAMES } from "../../semconv/spans.ts";
@@ -42,11 +48,11 @@ import {
 import { monotonicNowMs } from "../handler-runtime.ts";
 import type { HandlerRegistrar } from "../handler-runtime.ts";
 import type {
-  Handler,
   HandlerSessionState,
-  ObservMeHandlerContext,
   ObservMeTelemetrySession,
   PendingBashOperationState,
+  PiEvent,
+  PiHandler,
   ToolCallState,
 } from "../handler-types.ts";
 
@@ -56,7 +62,6 @@ export function registerToolBashHandlers(registrar: HandlerRegistrar, state: Han
   registrar.add("tool_result", createToolResultHandler(state));
   registrar.add("tool_execution_end", createToolExecutionEndHandler(state));
   registrar.add("user_bash", createUserBashPreExecutionHandler(state));
-  registrar.add("bashExecution", createBashExecutionHandler(state));
 }
 
 export function recordBashExecution(session: ObservMeTelemetrySession, event: unknown): void {
@@ -97,14 +102,14 @@ export function recordBashExecution(session: ObservMeTelemetrySession, event: un
   emitLifecycleLog(session.logger, LOG_EVENT_NAMES.BASH_COMPLETED, attributes, failed ? "ERROR" : "INFO");
 }
 
-function createToolExecutionStartHandler(state: HandlerSessionState): Handler {
+function createToolExecutionStartHandler(state: HandlerSessionState): PiHandler<"tool_execution_start"> {
   return handleToolExecutionStart.bind(undefined, state);
 }
 
 function handleToolExecutionStart(
   state: HandlerSessionState,
-  event: unknown,
-  _ctx: ObservMeHandlerContext,
+  event: PiEvent<"tool_execution_start">,
+  _ctx: ExtensionContext,
 ): void {
   const session = state.session;
   if (!session) return;
@@ -114,11 +119,11 @@ function handleToolExecutionStart(
   recordOptionalToolArguments(session, toolState.span, event);
 }
 
-function createToolCallHandler(state: HandlerSessionState): Handler {
+function createToolCallHandler(state: HandlerSessionState): PiHandler<"tool_call"> {
   return handleToolCall.bind(undefined, state);
 }
 
-function handleToolCall(state: HandlerSessionState, event: unknown, _ctx: ObservMeHandlerContext): void {
+function handleToolCall(state: HandlerSessionState, event: ToolCallEvent, _ctx: ExtensionContext): void {
   const session = state.session;
   if (!session) return;
   if (dropAmbiguousToolLifecycleEvent(session, event, "tool_call")) return;
@@ -132,11 +137,11 @@ function handleToolCall(state: HandlerSessionState, event: unknown, _ctx: Observ
   recordOptionalToolArguments(session, toolState.span, event);
 }
 
-function createToolResultHandler(state: HandlerSessionState): Handler {
+function createToolResultHandler(state: HandlerSessionState): PiHandler<"tool_result"> {
   return handleToolResult.bind(undefined, state);
 }
 
-function handleToolResult(state: HandlerSessionState, event: unknown, _ctx: ObservMeHandlerContext): void {
+function handleToolResult(state: HandlerSessionState, event: ToolResultEvent, _ctx: ExtensionContext): void {
   const session = state.session;
   if (!session) return;
   if (dropAmbiguousToolLifecycleEvent(session, event, "tool_result")) return;
@@ -155,14 +160,14 @@ function captureToolResult(session: ObservMeTelemetrySession, toolState: ToolCal
   if (capturedResult) toolState.capturedResult = capturedResult;
 }
 
-function createToolExecutionEndHandler(state: HandlerSessionState): Handler {
+function createToolExecutionEndHandler(state: HandlerSessionState): PiHandler<"tool_execution_end"> {
   return handleToolExecutionEnd.bind(undefined, state);
 }
 
 function handleToolExecutionEnd(
   state: HandlerSessionState,
-  event: unknown,
-  _ctx: ObservMeHandlerContext,
+  event: PiEvent<"tool_execution_end">,
+  _ctx: ExtensionContext,
 ): void {
   const session = state.session;
   if (!session) return;
@@ -202,14 +207,14 @@ function handleToolExecutionEnd(
   deleteCurrentToolCall(session, toolCallId);
 }
 
-function createUserBashPreExecutionHandler(state: HandlerSessionState): Handler {
+function createUserBashPreExecutionHandler(state: HandlerSessionState): PiHandler<"user_bash"> {
   return handleUserBashPreExecution.bind(undefined, state);
 }
 
 function handleUserBashPreExecution(
   state: HandlerSessionState,
-  event: unknown,
-  _ctx: ObservMeHandlerContext,
+  event: UserBashEvent,
+  _ctx: ExtensionContext,
 ): void {
   const session = state.session;
   if (!session) return;
@@ -217,17 +222,6 @@ function handleUserBashPreExecution(
   startPendingUserBashOperation(session, event);
 }
 
-function createBashExecutionHandler(state: HandlerSessionState): Handler {
-  return handleBashExecution.bind(undefined, state);
-}
-
-function handleBashExecution(state: HandlerSessionState, event: unknown, _ctx: ObservMeHandlerContext): void {
-  const session = state.session;
-  if (!session) return;
-
-  recordBashExecution(session, event);
-}
-
 function dropAmbiguousToolLifecycleEvent(
   session: ObservMeTelemetrySession,
   event: unknown,

package/src/pi/handler-internals.ts

@@ -345,7 +345,7 @@ export function buildLlmRequestAttributes(
     [LLM_ATTRIBUTES.GEN_AI_REQUEST_MODEL]: model,
     [LLM_ATTRIBUTES.GEN_AI_CONVERSATION_ID]: resolveCurrentSessionId(session),
     [LLM_ATTRIBUTES.PI_LLM_API]: readString(payload, "api") ?? readString(ctx.model, "api") ?? provider,
-    [LLM_ATTRIBUTES.PI_LLM_REQUEST_THINKING_LEVEL]: resolveSessionThinkingLevel(event, ctx, session),
+    [LLM_ATTRIBUTES.PI_LLM_REQUEST_THINKING_LEVEL]: resolveSessionThinkingLevel(event, session),
     [LLM_ATTRIBUTES.PI_LLM_REQUEST_MESSAGE_COUNT]: countPayloadItems(payload, ["messages", "contents", "input", "prompt"]),
     [LLM_ATTRIBUTES.PI_LLM_REQUEST_TOOL_SCHEMA_COUNT]: countPayloadItems(payload, ["tools", "toolSchemas"]),
     [LLM_ATTRIBUTES.PI_LLM_REQUEST_INPUT_CHARS]: safeJsonLength(payload),
@@ -1039,7 +1039,7 @@ export function buildModelChangeAttributes(event: unknown, ctx: ObservMeHandlerC
   });
 }
 
-export function buildThinkingLevelChangeAttributes(event: unknown, ctx: ObservMeHandlerContext, session: ObservMeTelemetrySession): AttributeMap {
+export function buildThinkingLevelChangeAttributes(event: unknown, session: ObservMeTelemetrySession): AttributeMap {
   return withoutUndefinedAttributes({
     ...buildLineageMetricSafeLogAttributes(session),
     [COMMON_SPAN_ATTRIBUTES.PI_AGENT_RUN_ID]: session.currentAgentRunId,
@@ -1047,7 +1047,7 @@ export function buildThinkingLevelChangeAttributes(event: unknown, ctx: ObservMe
     [COMMON_SPAN_ATTRIBUTES.PI_ENTRY_ID]: readChangeEntryId(event, "thinking_level_change"),
     [COMMON_SPAN_ATTRIBUTES.PI_ENTRY_PARENT_ID]: readChangeEntryParentId(event, "thinking_level_change"),
     [COMMON_SPAN_ATTRIBUTES.PI_ENTRY_TYPE]: readChangeEntryType(event, "thinking_level_change"),
-    [SESSION_ATTRIBUTES.PI_THINKING_LEVEL_CURRENT]: resolveSessionThinkingLevel(event, ctx, session),
+    [SESSION_ATTRIBUTES.PI_THINKING_LEVEL_CURRENT]: resolveSessionThinkingLevel(event, session),
   });
 }
 
@@ -1948,30 +1948,29 @@ export function extractThinkingText(value: unknown): string | undefined {
 }
 
 export function resolveSessionFilePath(event: unknown, ctx: ObservMeHandlerContext): string | undefined {
-  return readString(event, "sessionFile") ?? readString(event, "session_file") ?? readString(ctx, "sessionFile") ?? readString(ctx, "session_file");
+  return ctx.sessionManager?.getSessionFile() ?? readString(event, "sessionFile") ?? readString(event, "session_file");
 }
 
 export function resolveSessionId(event: unknown, ctx: ObservMeHandlerContext, lineage: AgentLineageContext): string {
   return (
+    ctx.sessionManager?.getSessionId() ??
     readString(event, "sessionId") ??
     readString(event, "session_id") ??
     readString(event, "id") ??
-    readString(ctx, "sessionId") ??
-    readString(ctx, "session_id") ??
     `session-${lineage.workflowId}`
   );
 }
 
-export function resolveModelProvider(event: unknown, ctx: ObservMeHandlerContext): string {
-  return readModelProvider(event, ctx) ?? "unknown";
+export function resolveModelProvider(ctx: ObservMeHandlerContext): string {
+  return readString(ctx.model, "provider") ?? "unknown";
 }
 
-export function resolveModelId(event: unknown, ctx: ObservMeHandlerContext): string {
-  return readModelId(event, ctx) ?? "unknown";
+export function resolveModelId(ctx: ObservMeHandlerContext): string {
+  return readString(ctx.model, "id") ?? "unknown";
 }
 
-export function resolveThinkingLevel(event: unknown, ctx: ObservMeHandlerContext): string {
-  return readThinkingLevel(event, ctx) ?? "unknown";
+export function resolveThinkingLevel(thinkingLevel: unknown): string {
+  return typeof thinkingLevel === "string" && thinkingLevel.trim() ? thinkingLevel.trim() : "unknown";
 }
 
 export function resolveSessionModelProvider(
@@ -1988,10 +1987,9 @@ export function resolveSessionModelId(event: unknown, ctx: ObservMeHandlerContex
 
 export function resolveSessionThinkingLevel(
   event: unknown,
-  ctx: ObservMeHandlerContext,
   session: ObservMeTelemetrySession,
 ): string {
-  return readThinkingLevel(event, ctx) ?? readString(session.sessionAttributes, SESSION_ATTRIBUTES.PI_THINKING_LEVEL_CURRENT) ?? "unknown";
+  return readThinkingLevel(event) ?? readString(session.sessionAttributes, SESSION_ATTRIBUTES.PI_THINKING_LEVEL_CURRENT) ?? "unknown";
 }
 
 export function readModelProvider(event: unknown, ctx: ObservMeHandlerContext): string | undefined {
@@ -2004,9 +2002,7 @@ export function readModelProvider(event: unknown, ctx: ObservMeHandlerContext):
     readString(payload, "model_provider") ??
     readString(selectedModel, "provider") ??
     readString(selectedModel, "modelProvider") ??
-    readString(ctx.model, "provider") ??
-    readString(ctx, "modelProvider") ??
-    readString(ctx, "model_provider")
+    readString(ctx.model, "provider")
   );
 }
 
@@ -2022,14 +2018,11 @@ export function readModelId(event: unknown, ctx: ObservMeHandlerContext): string
     readString(payload, "selection") ??
     readString(payload, "model") ??
     readModelIdFromObject(selectedModel) ??
-    readString(ctx.model, "id") ??
-    readString(ctx.model, "model") ??
-    readString(ctx, "modelId") ??
-    readString(ctx, "model_id")
+    readString(ctx.model, "id")
   );
 }
 
-export function readThinkingLevel(event: unknown, ctx: ObservMeHandlerContext): string | undefined {
+export function readThinkingLevel(event: unknown): string | undefined {
   const payload = readChangePayload(event, "thinking_level_change");
   const selectedThinking = readUnknown(payload, "thinking") ?? readUnknown(payload, "selection");
 
@@ -2038,10 +2031,7 @@ export function readThinkingLevel(event: unknown, ctx: ObservMeHandlerContext):
     readString(payload, "thinking_level") ??
     readString(payload, "level") ??
     readString(payload, "selection") ??
-    readString(selectedThinking, "level") ??
-    readString(ctx.thinking, "level") ??
-    readString(ctx, "thinkingLevel") ??
-    readString(ctx, "thinking_level")
+    readString(selectedThinking, "level")
   );
 }