fix: stop silently dropping telemetry event attributes

turn_ended now carries the engine error code when a turn fails, session
attribution keys emit empty strings so they survive payload flattening,
and properties a sink cannot accept are reported through a new
onUnexpectedError hook instead of vanishing. Properties are sanitized
when the sink accepts the event, so drops on events queued before
initialization are reported once a handler is installed.

Author: elkaix

apps/pythinker-code/src/cli/telemetry.ts

@@ -1,6 +1,7 @@
 import { createPythinkerDeviceId } from '@pymodel/pythinker-code-oauth';
 import {
   loadRuntimeConfigSafe,
+  log,
   resolveConfigPath,
   resolvePythinkerHome,
   type PythinkerConfig,
@@ -56,6 +57,7 @@ export function initializeCliTelemetry(options: InitializeCliTelemetryOptions):
     model: options.model ?? options.config.defaultModel,
     sessionId: options.sessionId,
     endpoint: () => currentPythinkerProfile().telemetryEndpoint,
+    onUnexpectedError: (error) => log.warn('telemetry property dropped', { error: String(error) }),
   });
   if (options.bootstrap.firstLaunch) {
     options.harness.track('first_launch');
@@ -98,6 +100,7 @@ export function initializeServerTelemetry(
     uiMode: WEB_UI_MODE,
     model: config.defaultModel,
     endpoint: () => currentPythinkerProfile().telemetryEndpoint,
+    onUnexpectedError: (error) => log.warn('telemetry property dropped', { error: String(error) }),
   });
 
   return {

apps/pythinker-code/test/cli/export.test.ts

@@ -430,6 +430,7 @@ describe('pythinker export', () => {
       model: 'k2',
       sessionId: undefined,
       endpoint: expect.any(Function),
+      onUnexpectedError: expect.any(Function),
     });
     // The endpoint resolver defers to the active region profile at flush time.
     const telemetryOptions = mocks.initializeTelemetry.mock.calls[0]![0] as {

apps/pythinker-code/test/cli/run-shell.test.ts

@@ -335,6 +335,7 @@ describe('runShell', () => {
       model: 'k2',
       sessionId: undefined,
       endpoint: expect.any(Function),
+      onUnexpectedError: expect.any(Function),
     });
     // The endpoint resolver defers to the active region profile at flush time.
     const telemetryOptions = mocks.initializeTelemetry.mock.calls[0]![0] as {

packages/agent-core-v2/src/agent/loop/loopService.ts

@@ -524,8 +524,9 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
         result?.type === 'completed'
           ? this.lastRequestTraceId
           : this.activeRequestTrace?.traceId;
+      const error =
+        result?.type === 'failed' ? toPythinkerErrorPayload(result.error) : undefined;
       if (result !== undefined) {
-        const error = result.type === 'failed' ? toPythinkerErrorPayload(result.error) : undefined;
         const interruptReason =
           result.type === 'completed' ? undefined : interruptReasonFor(result);
         const durationMs = Date.now() - startedAt;
@@ -563,6 +564,7 @@ export class AgentLoopService extends Disposable implements IAgentLoopService {
         reason: result?.type ?? 'failed',
         duration_ms: Date.now() - startedAt,
         mode,
+        error_type: error?.code,
         provider_type,
         protocol,
         thinking_effort: thinkingEffort,

packages/agent-core-v2/src/app/telemetry/events.ts

@@ -76,6 +76,7 @@ export interface TurnEndedEvent {
   reason: 'completed' | 'cancelled' | 'failed';
   duration_ms: number;
   mode: 'agent' | 'plan';
+  error_type?: string;
   provider_type?: string;
   protocol?: string;
   thinking_effort?: string;
@@ -608,6 +609,7 @@ export const telemetryEventDefinitions = {
       reason: 'How the turn ended',
       duration_ms: 'Turn wall-clock time in milliseconds',
       mode: 'Agent mode the turn ran in',
+      error_type: 'Engine error code when the turn failed; absent otherwise',
       provider_type: 'Provider protocol type',
       protocol: 'Request protocol',
       thinking_effort: 'Effective thinking effort the turn ran with',

packages/agent-core-v2/test/agent/loop/loop.test.ts

@@ -23,6 +23,7 @@ import { TurnEnded } from '#/agent/loop/turnOps';
 import { RetryStepRequest } from '#/agent/prompt/promptStepRequests';
 import type { ExecutableTool } from '#/tool/toolContract';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
+import { IAgentToolExecutorService } from '#/agent/toolExecutor/toolExecutor';
 import { IEventBus } from '#/app/event/eventBus';
 import { userCancellationReason } from '#/_base/utils/abort';
 
@@ -1172,6 +1173,7 @@ describe('turn telemetry', () => {
           turn_id: 0,
           reason: 'failed',
           mode: 'agent',
+          error_type: 'provider.filtered',
           trace_id: 'trace-turn-2',
         }),
       });
@@ -1180,6 +1182,45 @@ describe('turn telemetry', () => {
     }
   });
 
+  it('emits turn_ended with error_type for an uncoded failure', async () => {
+    const records: TelemetryRecord[] = [];
+    const local = createTestAgent({ telemetry: recordingTelemetry(records) });
+    try {
+      const workTool: ExecutableTool = {
+        name: 'Work',
+        description: 'Pretend to work.',
+        parameters: { type: 'object', properties: {}, additionalProperties: false },
+        resolveExecution: () => ({
+          approvalRule: 'Work',
+          execute: async () => ({ output: 'should never run' }),
+        }),
+      };
+      local.get(IAgentToolRegistryService).register(workTool);
+      local.get(IAgentProfileService).update({ activeToolNames: ['Work'] });
+      const subscription = local.get(IAgentToolExecutorService).onBeforeExecuteTool(() => {
+        throw new Error('beforeExecute blew up');
+      });
+      local.mockNextResponse(
+        { type: 'text', text: 'working' },
+        { type: 'function', id: 'call-work-1', name: 'Work', arguments: '{}' },
+      );
+      await local.rpc.prompt({ input: [{ type: 'text', text: 'use the tool' }] });
+      await local.untilTurnEnd();
+      subscription.dispose();
+
+      expect(records).toContainEqual({
+        event: 'turn_ended',
+        properties: expect.objectContaining({
+          turn_id: 0,
+          reason: 'failed',
+          error_type: 'internal',
+        }),
+      });
+    } finally {
+      await local.dispose();
+    }
+  });
+
   it.each([
     ['user_cancelled', () => userCancellationReason()],
     ['aborted', () => new Error('stop')],

packages/agent-core/src/agent/permission/policies/deny-all.ts

@@ -1,11 +1,19 @@
-import type { PermissionPolicy, PermissionPolicyResult } from '../types';
+import type { PermissionPolicy, PermissionPolicyContext, PermissionPolicyResult } from '../types';
 
+/**
+ * Denies every tool call except the read-only ones a side question may use to
+ * inspect current file contents.
+ */
 export class DenyAllPermissionPolicy implements PermissionPolicy {
   readonly name = 'deny-all';
 
-  constructor(private readonly message: string) {}
+  constructor(
+    private readonly message: string,
+    private readonly allowed: ReadonlySet<string> = new Set(),
+  ) {}
 
-  evaluate(): PermissionPolicyResult {
+  evaluate(context: PermissionPolicyContext): PermissionPolicyResult | undefined {
+    if (this.allowed.has(context.toolCall.name)) return undefined;
     return {
       kind: 'deny',
       message: this.message,

packages/agent-core/src/session/subagent-host.ts

@@ -93,20 +93,22 @@ const SUMMARY_CONTINUATION_ATTEMPTS = 1;
 const HOOK_TEXT_PREVIEW_LENGTH = 500;
 const SUBAGENT_MAX_TOKENS_ERROR =
   'Subagent turn failed before completing its final summary: reason=max_tokens';
+const BTW_READONLY_TOOLS = new Set(['Read', 'Grep', 'Glob']);
 const TOOL_CALL_DISABLED_MESSAGE =
-  'Tool calls are disabled for side questions. Answer with text only.';
+  'Only the read-only tools Read, Grep, and Glob are available for side questions. Other tool calls are disabled.';
 const SUBAGENT_PROMPT_ORIGIN: PromptOrigin = { kind: 'system_trigger', name: 'subagent' };
 const SIDE_QUESTION_SYSTEM_REMINDER = `
-This is a side-channel conversation with the user. You should answer user questions directly based on what you already know.
+This is a side-channel conversation with the user. You should answer user questions directly.
 
 IMPORTANT:
 - You are a separate, lightweight instance.
 - The main agent continues independently; do not reference being interrupted.
-- Do not call any tools. All tool calls are disabled and will be rejected.
-  Even though tool definitions are visible in this request, they exist only
-  for technical reasons (prompt cache). You must not use them.
-- Respond only with text based on what you already know from the conversation
-  and this side-channel conversation.
+- You may use the read-only tools Read, Grep, and Glob to inspect files when
+  the answer depends on current file contents. All other tools are disabled
+  and will be rejected, even though their definitions are visible in this
+  request (they exist only for technical reasons — prompt cache).
+- Prefer answering from what you already know from the conversation and this
+  side-channel conversation; reach for the read-only tools only when needed.
 - Follow-up turns may happen in this side-channel conversation.
 - If you do not know the answer, say so directly.
 `;
@@ -284,7 +286,7 @@ export class SessionSubagentHost {
       kind: 'system_trigger',
       name: 'btw',
     });
-    child.permission.policies.unshift(new DenyAllPermissionPolicy(TOOL_CALL_DISABLED_MESSAGE));
+    child.permission.policies.unshift(new DenyAllPermissionPolicy(TOOL_CALL_DISABLED_MESSAGE, BTW_READONLY_TOOLS));
     return id;
   }
 

packages/agent-core/test/session/init.test.ts

@@ -480,7 +480,7 @@ describe('AgentAPI.startBtw', () => {
       const historyText = JSON.stringify(scripted.calls[0]?.history);
       expect(historyText).toContain('Main task: implement /btw.');
       expect(historyText).toContain('This is a side-channel conversation with the user.');
-      expect(historyText).toContain('All tool calls are disabled and will be rejected.');
+      expect(historyText).toContain('All other tools are disabled');
       expect(historyText).toContain('What are you working on right now?');
       expect(historyText).not.toContain('call-open');
       expect(JSON.stringify(mainAgent.context.history)).not.toContain(
@@ -570,15 +570,16 @@ describe('AgentAPI.startBtw', () => {
         'Read',
       ]);
       expect(JSON.stringify(scripted.calls[1]?.history)).toContain(
-        'Tool calls are disabled for side questions. Answer with text only.',
+        'Only the read-only tools Read, Grep, and Glob are available for side questions.',
       );
       expect(events).toContainEqual(
         expect.objectContaining({
           type: 'tool.result',
           agentId: 'agent-0',
           toolCallId: 'call_lookup_note',
           isError: true,
-          output: 'Tool calls are disabled for side questions. Answer with text only.',
+          output:
+            'Only the read-only tools Read, Grep, and Glob are available for side questions. Other tool calls are disabled.',
         }),
       );
       expect(JSON.stringify(mainAgent.context.history)).not.toContain(

packages/node-sdk/src/pythinker-harness.ts

@@ -679,13 +679,12 @@ export class PythinkerHarness {
       ...this.sessionStartedDynamicProperties?.(),
       // Canonical fields are owned by the harness and must win over any
       // caller-supplied sessionStartedProperties that happen to share a key.
-      // `client_id` is always null here: a single-process host has no
-      // per-connection client id (that concept only exists for daemon clients,
-      // see core-impl.ts). Kept as an explicit key so both producers share the
-      // same session_started schema.
-      client_id: null,
-      client_name: this.identity?.productName ?? null,
-      client_version: this.identity?.version ?? null,
+      // A single-process host has no per-connection client id, so `client_id`
+      // stays empty; empty strings (unlike null) survive payload flattening,
+      // keeping the client-attribution keys present on every row.
+      client_id: '',
+      client_name: this.identity?.productName ?? '',
+      client_version: this.identity?.version ?? '',
       ui_mode: this.uiMode,
       resumed,
     });