@amaster.ai/pi-telemetry 0.1.1-beta.0 → 0.1.1

package/README.md

@@ -1,5 +1,7 @@
 # @amaster.ai/pi-telemetry
 
+![pi-telemetry preview](https://raw.githubusercontent.com/TGYD-helige/pi/master/packages/pi-telemetry/preview.png)
+
 Runtime telemetry contracts and exporters for pi.
 
 The root package exposes stable exporter contracts plus no-op and composite exporters. Provider-specific implementations live behind explicit subpath entry points so applications can depend on the smallest public surface they need.
@@ -7,55 +9,106 @@ The root package exposes stable exporter contracts plus no-op and composite expo
 ## Entry Points
 
 - `@amaster.ai/pi-telemetry`: stable contracts, `NoopRuntimeEventExporter`, and `CompositeRuntimeEventExporter`.
-- `@amaster.ai/pi-telemetry/langfuse`: Langfuse SDK and ingestion API exporters.
+- `@amaster.ai/pi-telemetry/config`: `TelemetryConfig` type, `resolveConfig`, and `loadConfigFromFile`.
+- `@amaster.ai/pi-telemetry/langfuse`: Langfuse SDK exporter.
 - `@amaster.ai/pi-telemetry/otel`: generic OTLP/HTTP traces exporter.
 
-## Langfuse
-
-```ts
-import { createRuntimeEventExporterFromEnv } from "@amaster.ai/pi-telemetry/langfuse";
-
-const exporter = createRuntimeEventExporterFromEnv(process.env);
+## Events
+
+The extension hooks into the following Pi lifecycle events:
+
+| Event | Telemetry action |
+|-------|-----------------|
+| `session_start` | Initialize exporters from config |
+| `input` | Start a new trace (traceId boundary = user input) |
+| `turn_start` | Begin a generation span |
+| `before_provider_request` | Record model input |
+| `after_provider_response` | Record model output, usage, latency |
+| `turn_end` | End generation span |
+| `tool_execution_start` | Begin tool span |
+| `tool_execution_end` | End tool span with result |
+| `message_end` | Publish accumulated trace to exporters |
+| `model_select` | Record model switch events |
+| `session_compact` | Record context compaction events |
+| `session_shutdown` | Flush and shutdown exporters |
+
+### Trace lifecycle
+
+Traces are scoped to user input boundaries (not individual turns). A single user message may trigger multiple LLM turns and tool calls — all grouped under one trace. The trace is published on `message_end`.
+
+## Configuration
+
+Configuration is read from `.pi/settings.json` under the `"pi-telemetry"` key. Project-level settings (`.pi/settings.json` in the working directory) take priority over user-level settings (`~/.pi/agent/settings.json`).
+
+```json
+{
+  "pi-telemetry": {
+    "serviceName": "my-service",
+    "serviceVersion": "1.0.0",
+    "includePayloads": true,
+    "langfuse": {
+      "enabled": true,
+      "publicKey": "pk-lf-...",
+      "secretKey": "sk-lf-...",
+      "baseUrl": "https://cloud.langfuse.com",
+      "flushAt": 20,
+      "flushIntervalMs": 5000
+    },
+    "otel": {
+      "enabled": true,
+      "endpoint": "https://otel-collector.example.com",
+      "headers": { "Authorization": "Bearer ..." },
+      "flushAt": 20,
+      "flushIntervalMs": 5000
+    }
+  }
+}
 ```
 
-Telemetry is disabled unless credentials are present. Supported environment variables include:
+### Config Fields
 
-- `LANGFUSE_ENABLED`
-- `LANGFUSE_PUBLIC_KEY`
-- `LANGFUSE_SECRET_KEY`
-- `LANGFUSE_BASE_URL`
-- `LANGFUSE_TRANSPORT`
-- `TELEMETRY_SERVICE_NAME`
-- `TELEMETRY_SERVICE_VERSION`
-- `TELEMETRY_INCLUDE_PAYLOADS`
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `serviceName` | `string` | `"pi-server"` | Service name for traces |
+| `serviceVersion` | `string` | — | Service version for traces |
+| `includePayloads` | `boolean` | `true` | Include chat payloads, tool args, LLM I/O |
 
-Set `TELEMETRY_INCLUDE_PAYLOADS=false` to remove chat payloads, tool args, and LLM input/output from exported telemetry. For finer control, construct a Langfuse exporter directly and pass `redactEvent`.
+### Langfuse Config
 
-## Generic OTEL
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `enabled` | `boolean` | `false` | Enable Langfuse exporter |
+| `publicKey` | `string` | — | Langfuse public API key |
+| `secretKey` | `string` | — | Langfuse secret API key |
+| `baseUrl` | `string` | `"https://cloud.langfuse.com"` | Langfuse server URL |
+| `flushAt` | `number` | `20` | Batch size before flush |
+| `flushIntervalMs` | `number` | `5000` | Flush interval in ms |
 
-```ts
-import { createOtelRuntimeEventExporterFromEnv } from "@amaster.ai/pi-telemetry/otel";
+### OTEL Config
 
-const exporter = createOtelRuntimeEventExporterFromEnv(process.env);
-```
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `enabled` | `boolean` | `false` | Enable OTEL exporter |
+| `endpoint` | `string` | — | OTLP traces endpoint |
+| `headers` | `Record<string, string>` | — | Request headers |
+| `flushAt` | `number` | `20` | Batch size before flush |
+| `flushIntervalMs` | `number` | `5000` | Flush interval in ms |
+| `errorLabel` | `string` | — | Custom label for error messages |
 
-Supported generic OTEL environment variables include:
+When the endpoint does not end with `/v1/traces`, the exporter appends `/v1/traces`.
 
-- `OTEL_EXPORTER_OTLP_ENDPOINT`
-- `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`
-- `OTEL_EXPORTER_OTLP_HEADERS`
-- `OTEL_EXPORTER_OTLP_TRACES_HEADERS`
-- `OTEL_BSP_MAX_EXPORT_BATCH_SIZE`
-- `OTEL_BSP_SCHEDULE_DELAY`
-- `OTEL_SERVICE_NAME`
-- `OTEL_RESOURCE_ATTRIBUTES`
-- `OTEL_SDK_DISABLED`
-- `TELEMETRY_INCLUDE_PAYLOADS`
-- `TELEMETRY_SERVICE_VERSION`
+## Programmatic Usage
 
-When the endpoint does not end with `/v1/traces`, the exporter appends `/v1/traces`.
-Use this entry point for any OTLP/HTTP collector, including Langfuse's OTEL endpoint.
+```ts
+import { loadConfigFromFile, resolveConfig } from "@amaster.ai/pi-telemetry/config";
+import { createLangfuseExporter } from "@amaster.ai/pi-telemetry/langfuse";
+import { createOtelExporter } from "@amaster.ai/pi-telemetry/otel";
+
+const config = resolveConfig(loadConfigFromFile());
+const langfuse = createLangfuseExporter(config);
+const otel = createOtelExporter(config);
+```
 
 ## Privacy
 
-Runtime events may include user prompts, assistant responses, tool arguments, tool outputs, and model inputs/outputs. Keep telemetry disabled by default in downstream applications unless users explicitly configure an exporter.
+Runtime events may include user prompts, assistant responses, tool arguments, tool outputs, and model inputs/outputs. Set `includePayloads: false` to strip these from exported telemetry. For finer control, construct an exporter directly and pass `redactEvent`.

package/dist/config.d.ts

@@ -0,0 +1,27 @@
+import { type PiSettingsOptions } from '@amaster.ai/pi-shared/settings';
+export interface LangfuseConfig {
+    enabled?: boolean;
+    publicKey?: string;
+    secretKey?: string;
+    baseUrl?: string;
+    flushAt?: number;
+    flushIntervalMs?: number;
+}
+export interface OtelConfig {
+    enabled?: boolean;
+    endpoint?: string;
+    headers?: Record<string, string>;
+    flushAt?: number;
+    flushIntervalMs?: number;
+    errorLabel?: string;
+}
+export interface TelemetryConfig {
+    serviceName?: string;
+    serviceVersion?: string;
+    includePayloads?: boolean;
+    langfuse?: LangfuseConfig;
+    otel?: OtelConfig;
+}
+export declare function resolveConfig(config?: TelemetryConfig): TelemetryConfig;
+export declare function loadConfigFromFile(options?: PiSettingsOptions): TelemetryConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAGxF,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAOD,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,eAAe,GAAG,eAAe,CAEvE;AAED,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,eAAe,CAE/E"}

package/dist/config.js

@@ -0,0 +1,13 @@
+import { loadPiSettings } from '@amaster.ai/pi-shared/settings';
+import { getAgentDir } from '@earendil-works/pi-coding-agent';
+const DEFAULTS = {
+    serviceName: 'pi-server',
+    includePayloads: true,
+};
+export function resolveConfig(config) {
+    return { ...DEFAULTS, ...config };
+}
+export function loadConfigFromFile(options) {
+    return loadPiSettings('pi-telemetry', { agentDir: getAgentDir(), ...options });
+}
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAA0B,MAAM,gCAAgC,CAAC;AACxF,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AA6B9D,MAAM,QAAQ,GAAoB;IAChC,WAAW,EAAE,WAAW;IACxB,eAAe,EAAE,IAAI;CACtB,CAAC;AAEF,MAAM,UAAU,aAAa,CAAC,MAAwB;IACpD,OAAO,EAAE,GAAG,QAAQ,EAAE,GAAG,MAAM,EAAE,CAAC;AACpC,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,OAA2B;IAC5D,OAAO,cAAc,CAAkB,cAAc,EAAE,EAAE,QAAQ,EAAE,WAAW,EAAE,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;AAClG,CAAC"}

package/dist/extension.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../src/extension.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAmBpE,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAwHjE"}
+{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../src/extension.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,iCAAiC,CAAC;AAqKtF,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAsQjE"}

package/dist/extension.js

@@ -1,26 +1,169 @@
 import { randomUUID } from 'node:crypto';
+import { loadConfigFromFile, resolveConfig } from './config.js';
 import { CompositeRuntimeEventExporter, NoopRuntimeEventExporter, } from './index.js';
-import { createRuntimeEventExporterFromEnv } from './langfuse.js';
-import { createOtelRuntimeEventExporterFromEnv } from './otel.js';
-function extractModelConfig(payload) {
-    if (payload && typeof payload === 'object' && 'model' in payload) {
-        const model = payload.model;
-        if (typeof model === 'string') {
-            return { provider: 'unknown', model };
+import { createLangfuseExporter } from './langfuse.js';
+import { createOtelExporter } from './otel.js';
+function modelConfigFromCtx(ctx) {
+    const model = ctx.model;
+    if (!model) {
+        return { provider: 'unknown', model: 'unknown' };
+    }
+    return {
+        provider: model.provider ?? 'unknown',
+        model: model.id ?? model.name ?? 'unknown',
+    };
+}
+function extractOutput(message) {
+    if (!message || typeof message !== 'object')
+        return undefined;
+    const msg = message;
+    if (msg.role !== 'assistant' || !Array.isArray(msg.content))
+        return undefined;
+    const texts = [];
+    for (const block of msg.content) {
+        if (block &&
+            typeof block === 'object' &&
+            'type' in block &&
+            block.type === 'text' &&
+            'text' in block) {
+            texts.push(String(block.text));
+        }
+    }
+    return texts.length > 0 ? texts.join('\n') : undefined;
+}
+function simplifyContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content) || content.length === 0)
+        return content;
+    const allText = content.every((b) => b && typeof b === 'object' && 'type' in b && b.type === 'text');
+    if (allText) {
+        const texts = content.map((b) => String(b.text));
+        return texts.join('\n');
+    }
+    return content;
+}
+function toolEventDetails(result) {
+    const rawDetails = result && typeof result === 'object' && !Array.isArray(result)
+        ? result.details
+        : undefined;
+    const details = sanitizeToolDetails(rawDetails);
+    const output = summarizeToolResultOutput(result, rawDetails);
+    if (output !== undefined && details.output === undefined) {
+        details.output = output;
+    }
+    return Object.keys(details).length > 0 ? details : undefined;
+}
+function sanitizeToolDetails(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return {};
+    }
+    const sanitized = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (key === 'fullOutput' || key === 'fullOutputMimeType') {
+            continue;
         }
+        sanitized[key] = toTelemetryValue(raw);
+    }
+    return sanitized;
+}
+function summarizeToolResultOutput(result, details) {
+    if (result === undefined || shouldSuppressToolOutput(details)) {
+        return undefined;
+    }
+    if (typeof result === 'string') {
+        return summarizeString(result);
+    }
+    if (!result || typeof result !== 'object' || Array.isArray(result)) {
+        return toTelemetryValue(result);
+    }
+    const resultRecord = result;
+    if (resultRecord.output !== undefined) {
+        return toTelemetryValue(resultRecord.output);
+    }
+    const text = textContentFromToolResult(resultRecord);
+    if (text) {
+        return summarizeString(text);
+    }
+    return resultRecord.content !== undefined ? toTelemetryValue(resultRecord.content) : undefined;
+}
+function textContentFromToolResult(result) {
+    if (!Array.isArray(result.content)) {
+        return undefined;
+    }
+    const text = result.content
+        .filter((item) => item && typeof item === 'object' && !Array.isArray(item))
+        .map((item) => {
+        const record = item;
+        return typeof record.text === 'string' ? record.text : undefined;
+    })
+        .filter(Boolean)
+        .join('\n');
+    return text || undefined;
+}
+function shouldSuppressToolOutput(details) {
+    return Boolean(details &&
+        typeof details === 'object' &&
+        !Array.isArray(details) &&
+        details.outputSuppressed === true);
+}
+function toTelemetryValue(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return summarizeString(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map(toTelemetryValue).filter((item) => item !== undefined);
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, raw]) => [key, toTelemetryValue(raw)]));
     }
-    return { provider: 'unknown', model: 'unknown' };
+    return String(value);
+}
+function summarizeString(value) {
+    return value.length > 500
+        ? `${value.slice(0, 500)}... [truncated ${value.length - 500} chars]`
+        : value;
+}
+function mapUsage(usage) {
+    const result = {};
+    if (typeof usage.input === 'number')
+        result.input = usage.input;
+    if (typeof usage.output === 'number')
+        result.output = usage.output;
+    if (typeof usage.cacheRead === 'number')
+        result.cacheRead = usage.cacheRead;
+    if (typeof usage.cacheWrite === 'number')
+        result.cacheWrite = usage.cacheWrite;
+    if (typeof usage.totalTokens === 'number')
+        result.totalTokens = usage.totalTokens;
+    if (usage.cost != null && typeof usage.cost === 'object')
+        result.cost = usage.cost;
+    return result;
 }
 export default function telemetryExtension(pi) {
+    const inheritedTraceId = process.env.PI_TELEMETRY_TRACE_ID;
+    const inheritedSessionId = process.env.PI_TELEMETRY_SESSION_ID;
+    const ownerPid = process.env.PI_TELEMETRY_OWNER_PID;
+    const isSubagent = Boolean(inheritedTraceId && ownerPid && ownerPid !== String(process.pid));
     let exporter = new NoopRuntimeEventExporter();
-    const sessionId = randomUUID();
-    let currentTraceId;
-    let turnStartTime;
+    const localSessionId = randomUUID();
+    const sessionId = isSubagent && inheritedSessionId ? inheritedSessionId : localSessionId;
+    let currentTraceId = isSubagent ? inheritedTraceId : undefined;
+    let traceStartTime;
+    let tracePublished = false;
     let llmGenerationCounter = 0;
-    pi.on('session_start', async () => {
-        const env = process.env;
-        const langfuse = createRuntimeEventExporterFromEnv(env);
-        const otel = createOtelRuntimeEventExporterFromEnv(env);
+    let pendingInput;
+    let lastModelConfig = { provider: 'unknown', model: 'unknown' };
+    pi.on('session_start', async (_event, ctx) => {
+        const config = resolveConfig(loadConfigFromFile({ cwd: ctx.cwd }));
+        const langfuse = createLangfuseExporter(config);
+        const otel = createOtelExporter(config);
         const active = [langfuse, otel].filter((e) => !(e instanceof NoopRuntimeEventExporter));
         if (active.length > 1) {
             exporter = new CompositeRuntimeEventExporter(active);
@@ -29,33 +172,82 @@ export default function telemetryExtension(pi) {
             exporter = active[0];
         }
     });
-    pi.on('turn_start', async (event) => {
-        currentTraceId = randomUUID().replace(/-/g, '');
-        turnStartTime = event.timestamp;
+    pi.on('input', async (event) => {
+        pendingInput = event.text;
+        if (!isSubagent) {
+            currentTraceId = randomUUID().replace(/-/g, '');
+            process.env.PI_TELEMETRY_TRACE_ID = currentTraceId;
+            process.env.PI_TELEMETRY_SESSION_ID = sessionId;
+            process.env.PI_TELEMETRY_OWNER_PID = String(process.pid);
+        }
+        traceStartTime = undefined;
+        tracePublished = false;
         llmGenerationCounter = 0;
-        await exporter.publish({
-            id: randomUUID(),
-            traceId: currentTraceId,
-            type: 'chat_turn_started',
-            sessionId,
-            createdAt: new Date(event.timestamp).toISOString(),
-        });
     });
-    pi.on('turn_end', async () => {
+    pi.on('turn_start', async (event) => {
+        if (!currentTraceId) {
+            currentTraceId = randomUUID().replace(/-/g, '');
+            llmGenerationCounter = 0;
+            tracePublished = false;
+        }
+        if (!traceStartTime) {
+            traceStartTime = event.timestamp;
+        }
+        if (!tracePublished) {
+            tracePublished = true;
+            if (isSubagent) {
+                await exporter.publish({
+                    id: randomUUID(),
+                    traceId: currentTraceId,
+                    type: 'subagent_started',
+                    sessionId,
+                    childSessionId: localSessionId,
+                    createdAt: new Date(event.timestamp).toISOString(),
+                    ...(pendingInput !== undefined ? { details: { input: pendingInput } } : {}),
+                });
+            }
+            else {
+                await exporter.publish({
+                    id: randomUUID(),
+                    traceId: currentTraceId,
+                    type: 'chat_turn_started',
+                    sessionId,
+                    createdAt: new Date(event.timestamp).toISOString(),
+                    ...(pendingInput !== undefined ? { details: { input: pendingInput } } : {}),
+                });
+            }
+            pendingInput = undefined;
+        }
+    });
+    pi.on('turn_end', async (event) => {
         if (!currentTraceId)
             return;
         const now = Date.now();
-        const durationMs = turnStartTime ? now - turnStartTime : undefined;
-        await exporter.publish({
-            id: randomUUID(),
-            traceId: currentTraceId,
-            type: 'chat_turn_completed',
-            sessionId,
-            createdAt: new Date(now).toISOString(),
-            ...(durationMs !== undefined ? { durationMs } : {}),
-        });
-        currentTraceId = undefined;
-        turnStartTime = undefined;
+        const durationMs = traceStartTime ? now - traceStartTime : undefined;
+        const output = extractOutput(event.message);
+        if (isSubagent) {
+            await exporter.publish({
+                id: randomUUID(),
+                traceId: currentTraceId,
+                type: 'subagent_completed',
+                sessionId,
+                childSessionId: localSessionId,
+                createdAt: new Date(now).toISOString(),
+                ...(durationMs !== undefined ? { durationMs } : {}),
+                ...(output !== undefined ? { details: { output } } : {}),
+            });
+        }
+        else {
+            await exporter.publish({
+                id: randomUUID(),
+                traceId: currentTraceId,
+                type: 'chat_turn_completed',
+                sessionId,
+                createdAt: new Date(now).toISOString(),
+                ...(durationMs !== undefined ? { durationMs } : {}),
+                ...(output !== undefined ? { details: { output } } : {}),
+            });
+        }
     });
     pi.on('tool_execution_start', async (event) => {
         if (!currentTraceId)
@@ -63,8 +255,9 @@ export default function telemetryExtension(pi) {
         await exporter.publish({
             id: randomUUID(),
             traceId: currentTraceId,
-            sessionId,
-            conversationId: sessionId,
+            sessionId: localSessionId,
+            conversationId: localSessionId,
+            ...(isSubagent ? { childSessionId: localSessionId } : {}),
             toolCallId: event.toolCallId,
             toolName: event.toolName,
             status: 'started',
@@ -75,46 +268,130 @@ export default function telemetryExtension(pi) {
     pi.on('tool_execution_end', async (event) => {
         if (!currentTraceId)
             return;
+        const details = toolEventDetails(event.result);
         await exporter.publish({
             id: randomUUID(),
             traceId: currentTraceId,
-            sessionId,
-            conversationId: sessionId,
+            sessionId: localSessionId,
+            conversationId: localSessionId,
+            ...(isSubagent ? { childSessionId: localSessionId } : {}),
             toolCallId: event.toolCallId,
             toolName: event.toolName,
             status: event.isError ? 'failed' : 'completed',
             createdAt: new Date().toISOString(),
-            ...(event.isError ? { error: String(event.result) } : {}),
+            ...(details ? { details } : {}),
+            ...(event.isError
+                ? { error: typeof event.result === 'string' ? event.result : JSON.stringify(event.result) }
+                : {}),
         });
     });
-    pi.on('before_provider_request', async (event) => {
+    pi.on('before_provider_request', async (event, ctx) => {
         if (!currentTraceId)
             return;
         llmGenerationCounter++;
+        lastModelConfig = modelConfigFromCtx(ctx);
         await exporter.publish({
             id: randomUUID(),
             traceId: currentTraceId,
-            sessionId,
-            conversationId: sessionId,
+            sessionId: localSessionId,
+            conversationId: localSessionId,
+            ...(isSubagent ? { childSessionId: localSessionId } : {}),
             llmGenerationId: `gen-${llmGenerationCounter}`,
             status: 'started',
             createdAt: new Date().toISOString(),
-            model: extractModelConfig(event.payload),
+            model: lastModelConfig,
+            input: event.payload,
         });
     });
-    pi.on('after_provider_response', async (event) => {
+    pi.on('after_provider_response', async (event, ctx) => {
         if (!currentTraceId)
             return;
+        if (event.status < 400)
+            return;
         await exporter.publish({
             id: randomUUID(),
             traceId: currentTraceId,
-            sessionId,
-            conversationId: sessionId,
+            sessionId: localSessionId,
+            conversationId: localSessionId,
+            ...(isSubagent ? { childSessionId: localSessionId } : {}),
             llmGenerationId: `gen-${llmGenerationCounter}`,
-            status: event.status >= 400 ? 'failed' : 'completed',
+            status: 'failed',
+            createdAt: new Date().toISOString(),
+            model: modelConfigFromCtx(ctx),
+            error: `HTTP ${event.status}`,
+        });
+    });
+    pi.on('message_end', async (event) => {
+        if (!currentTraceId)
+            return;
+        const msg = event.message;
+        if (msg.role !== 'assistant')
+            return;
+        const content = simplifyContent(msg.content) ?? extractOutput(event.message);
+        const usage = msg.usage;
+        const mapped = usage ? mapUsage(usage) : undefined;
+        const output = {};
+        if (content !== undefined)
+            output.content = content;
+        if (usage !== undefined)
+            output.usage = usage;
+        await exporter.publish({
+            id: randomUUID(),
+            traceId: currentTraceId,
+            sessionId: localSessionId,
+            conversationId: localSessionId,
+            ...(isSubagent ? { childSessionId: localSessionId } : {}),
+            llmGenerationId: `gen-${llmGenerationCounter}`,
+            status: 'completed',
+            createdAt: new Date().toISOString(),
+            model: lastModelConfig,
+            ...(Object.keys(output).length > 0 ? { output } : {}),
+            ...(mapped ? { usage: mapped } : {}),
+            ...(typeof msg.responseId === 'string' ? { responseId: msg.responseId } : {}),
+            ...(typeof msg.stopReason === 'string' ? { stopReason: msg.stopReason } : {}),
+        });
+    });
+    pi.on('model_select', async (event) => {
+        if (!currentTraceId)
+            return;
+        const evt = event;
+        const model = evt.model;
+        const previousModel = evt.previousModel;
+        await exporter.publish({
+            id: randomUUID(),
+            traceId: currentTraceId,
+            type: 'chat_turn_steered',
+            sessionId,
+            createdAt: new Date().toISOString(),
+            details: {
+                eventType: 'model_switch',
+                from: previousModel
+                    ? {
+                        provider: String(previousModel.provider ?? 'unknown'),
+                        model: String(previousModel.id ?? 'unknown'),
+                    }
+                    : null,
+                to: model
+                    ? { provider: String(model.provider ?? 'unknown'), model: String(model.id ?? 'unknown') }
+                    : null,
+                source: String(evt.source ?? 'unknown'),
+            },
+        });
+    });
+    pi.on('session_compact', async (event) => {
+        if (!currentTraceId)
+            return;
+        const evt = event;
+        await exporter.publish({
+            id: randomUUID(),
+            traceId: currentTraceId,
+            type: 'chat_turn_steered',
+            sessionId,
             createdAt: new Date().toISOString(),
-            model: extractModelConfig(undefined),
-            ...(event.status >= 400 ? { error: `HTTP ${event.status}` } : {}),
+            details: {
+                eventType: 'session_compact',
+                fromExtension: evt.fromExtension ?? false,
+            },
         });
     });
     pi.on('session_shutdown', async () => {