pybao-xc-sdk 1.5.51

package/dist/index.js

@@ -0,0 +1,2423 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BackendKindSchema: () => BackendKindSchema,
+  ContentBlockSchema: () => ContentBlockSchema,
+  DEFAULT_SESSION_BACKEND_ROUTER_CONFIG: () => DEFAULT_SESSION_BACKEND_ROUTER_CONFIG,
+  DualTrackMetricsSchema: () => DualTrackMetricsSchema,
+  DualTrackRawStatsSchema: () => DualTrackRawStatsSchema,
+  DualTrackThresholdsSchema: () => DualTrackThresholdsSchema,
+  ErrorEventSchema: () => ErrorEventSchema,
+  ErrorStreamEventSchema: () => ErrorStreamEventSchema,
+  FALLBACK_TRIGGER_MATRIX: () => FALLBACK_TRIGGER_MATRIX,
+  FallbackTriggerReasonSchema: () => FallbackTriggerReasonSchema,
+  MessageCompletedEventSchema: () => MessageCompletedEventSchema,
+  MessageCreatedEventSchema: () => MessageCreatedEventSchema,
+  MessageSchema: () => MessageSchema,
+  MessageUpdatedEventSchema: () => MessageUpdatedEventSchema,
+  PROTOCOL_ERROR_TO_RUNTIME_ERROR_TYPE: () => PROTOCOL_ERROR_TO_RUNTIME_ERROR_TYPE,
+  PermissionRequestedEventSchema: () => PermissionRequestedEventSchema,
+  PermissionRespondedEventSchema: () => PermissionRespondedEventSchema,
+  PermissionTimeoutEventSchema: () => PermissionTimeoutEventSchema,
+  ProtocolErrorCodeSchema: () => ProtocolErrorCodeSchema,
+  ProtocolErrorMappingSchema: () => ProtocolErrorMappingSchema,
+  ProtocolSessionStreamBindingManager: () => ProtocolSessionStreamBindingManager,
+  PybClient: () => PybClient,
+  PybSSEEventSchema: () => PybSSEEventSchema,
+  RequestCompletedEventSchema: () => RequestCompletedEventSchema,
+  RequestStartedEventSchema: () => RequestStartedEventSchema,
+  RuntimeEventDomainSchema: () => RuntimeEventDomainSchema,
+  RuntimeEventErrorTypeSchema: () => RuntimeEventErrorTypeSchema,
+  RuntimeEventSchema: () => RuntimeEventSchema,
+  RuntimeSessionEventSchema: () => RuntimeSessionEventSchema,
+  RuntimeSessionInputSchema: () => RuntimeSessionInputSchema,
+  RuntimeSessionStatusSchema: () => RuntimeSessionStatusSchema,
+  S4_PROTOCOL_ERROR_TOP_CODES: () => S4_PROTOCOL_ERROR_TOP_CODES,
+  S5_A0_EQUIVALENCE_SAMPLE_SET: () => S5_A0_EQUIVALENCE_SAMPLE_SET,
+  SDK_VERSION: () => SDK_VERSION,
+  SESSION_BACKEND_CONFIG_CONTRACT_VERSION: () => SESSION_BACKEND_CONFIG_CONTRACT_VERSION,
+  SESSION_BACKEND_ENV_KEY: () => SESSION_BACKEND_ENV_KEY,
+  SESSION_BACKEND_OBSERVABILITY_SPEC: () => SESSION_BACKEND_OBSERVABILITY_SPEC,
+  SSEClient: () => SSEClient,
+  SSEDedupEventSchema: () => SSEDedupEventSchema,
+  SSEReplayEventSchema: () => SSEReplayEventSchema,
+  SSEReplayGapEventSchema: () => SSEReplayGapEventSchema,
+  ServerConnectedEventSchema: () => ServerConnectedEventSchema,
+  ServerHeartbeatEventSchema: () => ServerHeartbeatEventSchema,
+  ServerStatusEventSchema: () => ServerStatusEventSchema,
+  SessionBackendRouterConfigSchema: () => SessionBackendRouterConfigSchema,
+  SessionCreatedEventSchema: () => SessionCreatedEventSchema,
+  SessionDeletedEventSchema: () => SessionDeletedEventSchema,
+  SessionUpdatedEventSchema: () => SessionUpdatedEventSchema,
+  ToolCompletedEventSchema: () => ToolCompletedEventSchema,
+  ToolErrorEventSchema: () => ToolErrorEventSchema,
+  ToolProgressEventSchema: () => ToolProgressEventSchema,
+  ToolStartedEventSchema: () => ToolStartedEventSchema,
+  V2MessageSchema: () => V2MessageSchema,
+  V2RequestStatusSchema: () => V2RequestStatusSchema,
+  V2SessionSchema: () => V2SessionSchema,
+  V2SessionStatusSchema: () => V2SessionStatusSchema,
+  V2ToolUseContextSchema: () => V2ToolUseContextSchema,
+  buildDefaultDualTrackThresholds: () => buildDefaultDualTrackThresholds,
+  buildV2ToolUseContextFromPromptRequest: () => buildV2ToolUseContextFromPromptRequest,
+  canTransitionV2SessionStatus: () => canTransitionV2SessionStatus,
+  createDefaultToolPermissionContextForSdk: () => createDefaultToolPermissionContextForSdk,
+  createProtocolSessionBackend: () => createProtocolSessionBackend,
+  createRuntimePermissionContextForSession: () => createRuntimePermissionContextForSession,
+  createRuntimeSession: () => createRuntimeSession,
+  createRuntimeSessionBackend: () => createRuntimeSessionBackend,
+  createSSEClient: () => createSSEClient,
+  createSessionBackendRouter: () => createSessionBackendRouter,
+  emitBackendConfigWarning: () => emitBackendConfigWarning,
+  evaluateDualTrackMetrics: () => evaluateDualTrackMetrics,
+  evaluateV1DeprecationReadiness: () => evaluateV1DeprecationReadiness,
+  getRuntimeEventMappingRules: () => getRuntimeEventMappingRules,
+  isToolAutoExecutableInContext: () => isToolAutoExecutableInContext,
+  mapProtocolErrorCodeToRuntimeErrorType: () => mapProtocolErrorCodeToRuntimeErrorType,
+  mapRuntimeBackendErrorToRuntimeEvent: () => mapRuntimeBackendErrorToRuntimeEvent,
+  mapRuntimeMessageToV2: () => mapRuntimeMessageToV2,
+  mapRuntimeSessionStatusToV2: () => mapRuntimeSessionStatusToV2,
+  mapV1MessageToV2: () => mapV1MessageToV2,
+  mapV1SessionStatusToV2: () => mapV1SessionStatusToV2,
+  projectLegacyEventToRuntimeEvent: () => projectLegacyEventToRuntimeEvent,
+  projectRuntimeEventToLegacyEvent: () => projectRuntimeEventToLegacyEvent,
+  resolveDefaultBackend: () => resolveDefaultBackend,
+  resolveDefaultBackendFromEnv: () => resolveDefaultBackendFromEnv,
+  resolvePermissionDecision: () => resolvePermissionDecision,
+  resolvePermissionModeForSdk: () => resolvePermissionModeForSdk,
+  resolveRouterBackendKind: () => resolveRouterBackendKind,
+  shouldTriggerFallback: () => shouldTriggerFallback,
+  validateV2Message: () => validateV2Message,
+  validateV2Session: () => validateV2Session,
+  validateV2ToolUseContext: () => validateV2ToolUseContext
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var import_zod = require("zod");
+var ServerConnectedEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("server.connected"),
+  timestamp: import_zod.z.number(),
+  data: import_zod.z.object({
+    serverVersion: import_zod.z.string(),
+    protocolVersion: import_zod.z.string(),
+    features: import_zod.z.array(import_zod.z.string())
+  })
+});
+var ServerHeartbeatEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("server.heartbeat"),
+  timestamp: import_zod.z.number(),
+  data: import_zod.z.object({
+    timestamp: import_zod.z.number()
+  })
+});
+var ServerStatusEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("server.status"),
+  timestamp: import_zod.z.number(),
+  data: import_zod.z.object({
+    status: import_zod.z.enum(["healthy", "degraded", "unhealthy"]),
+    components: import_zod.z.object({
+      llm: import_zod.z.enum(["connected", "disconnected"]),
+      mcp: import_zod.z.enum(["connected", "disconnected"]),
+      tools: import_zod.z.enum(["ready", "initializing"])
+    })
+  })
+});
+var SessionCreatedEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("session.created"),
+  timestamp: import_zod.z.number(),
+  data: import_zod.z.object({
+    sessionId: import_zod.z.string(),
+    config: import_zod.z.object({
+      model: import_zod.z.string(),
+      agent: import_zod.z.string(),
+      outputStyle: import_zod.z.string()
+    }),
+    resumedFrom: import_zod.z.string().optional()
+  })
+});
+var SessionUpdatedEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("session.updated"),
+  timestamp: import_zod.z.number(),
+  sessionId: import_zod.z.string(),
+  data: import_zod.z.object({
+    title: import_zod.z.string().optional(),
+    config: import_zod.z.object({
+      model: import_zod.z.string().optional(),
+      agent: import_zod.z.string().optional(),
+      outputStyle: import_zod.z.string().optional()
+    }).optional()
+  })
+});
+var SessionDeletedEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("session.deleted"),
+  timestamp: import_zod.z.number(),
+  data: import_zod.z.object({
+    sessionId: import_zod.z.string()
+  })
+});
+var ContentBlockSchema = import_zod.z.discriminatedUnion("type", [
+  import_zod.z.object({ type: import_zod.z.literal("text"), text: import_zod.z.string() }),
+  import_zod.z.object({
+    type: import_zod.z.literal("tool_use"),
+    id: import_zod.z.string(),
+    name: import_zod.z.string(),
+    input: import_zod.z.record(import_zod.z.unknown())
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("tool_result"),
+    toolUseId: import_zod.z.string(),
+    content: import_zod.z.string(),
+    isError: import_zod.z.boolean().optional()
+  })
+]);
+var MessageSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  role: import_zod.z.enum(["user", "assistant", "system"]),
+  content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ContentBlockSchema)]),
+  timestamp: import_zod.z.number(),
+  parentId: import_zod.z.string().optional(),
+  toolCalls: import_zod.z.array(import_zod.z.object({
+    id: import_zod.z.string(),
+    name: import_zod.z.string(),
+    input: import_zod.z.record(import_zod.z.unknown()),
+    status: import_zod.z.enum(["pending", "running", "completed", "error"]).optional(),
+    result: import_zod.z.string().optional()
+  })).optional(),
+  cost: import_zod.z.object({
+    inputTokens: import_zod.z.number(),
+    outputTokens: import_zod.z.number(),
+    costUSD: import_zod.z.number()
+  }).optional()
+});
+var MessageCreatedEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("message.created"),
+  timestamp: import_zod.z.number(),
+  sessionId: import_zod.z.string(),
+  data: import_zod.z.object({
+    message: import_zod.z.unknown()
+  })
+});
+var MessageUpdatedEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("message.updated"),
+  timestamp: import_zod.z.number(),
+  sessionId: import_zod.z.string(),
+  data: import_zod.z.object({
+    message: import_zod.z.unknown(),
+    delta: import_zod.z.object({
+      type: import_zod.z.enum(["text", "tool_use"]),
+      content: import_zod.z.string(),
+      index: import_zod.z.number().optional()
+    }).optional()
+  })
+});
+var MessageCompletedEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("message.completed"),
+  timestamp: import_zod.z.number(),
+  sessionId: import_zod.z.string(),
+  data: import_zod.z.object({
+    messageId: import_zod.z.string(),
+    finishReason: import_zod.z.enum(["end_turn", "tool_calls", "max_tokens", "aborted"]),
+    usage: import_zod.z.object({
+      inputTokens: import_zod.z.number(),
+      outputTokens: import_zod.z.number(),
+      totalTokens: import_zod.z.number()
+    }),
+    cost: import_zod.z.object({
+      costUSD: import_zod.z.number()
+    })
+  })
+});
+var RequestStartedEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("request.started"),
+  timestamp: import_zod.z.number(),
+  sessionId: import_zod.z.string(),
+  data: import_zod.z.object({
+    requestId: import_zod.z.string(),
+    userMessage: import_zod.z.string()
+  })
+});
+var RequestCompletedEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("request.completed"),
+  timestamp: import_zod.z.number(),
+  sessionId: import_zod.z.string(),
+  data: import_zod.z.object({
+    requestId: import_zod.z.string(),
+    finishReason: import_zod.z.enum(["end_turn", "tool_calls", "max_tokens", "aborted"]),
+    duration: import_zod.z.number(),
+    totalTokens: import_zod.z.number(),
+    costUSD: import_zod.z.number()
+  })
+});
+var ToolStartedEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("tool.started"),
+  timestamp: import_zod.z.number(),
+  sessionId: import_zod.z.string(),
+  data: import_zod.z.object({
+    toolUseId: import_zod.z.string(),
+    toolName: import_zod.z.string(),
+    input: import_zod.z.record(import_zod.z.unknown()),
+    dangerousLevel: import_zod.z.enum(["safe", "moderate", "dangerous"]),
+    requiresPermission: import_zod.z.boolean()
+  })
+});
+var ToolProgressEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("tool.progress"),
+  timestamp: import_zod.z.number(),
+  sessionId: import_zod.z.string(),
+  data: import_zod.z.object({
+    toolUseId: import_zod.z.string(),
+    toolName: import_zod.z.string(),
+    progress: import_zod.z.number().min(0).max(100),
+    message: import_zod.z.string().optional(),
+    output: import_zod.z.string().optional()
+  })
+});
+var ToolCompletedEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("tool.completed"),
+  timestamp: import_zod.z.number(),
+  sessionId: import_zod.z.string(),
+  data: import_zod.z.object({
+    toolUseId: import_zod.z.string(),
+    toolName: import_zod.z.string(),
+    result: import_zod.z.string(),
+    isError: import_zod.z.boolean(),
+    duration: import_zod.z.number()
+  })
+});
+var ToolErrorEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("tool.error"),
+  timestamp: import_zod.z.number(),
+  sessionId: import_zod.z.string(),
+  data: import_zod.z.object({
+    toolUseId: import_zod.z.string(),
+    toolName: import_zod.z.string(),
+    error: import_zod.z.object({
+      code: import_zod.z.string(),
+      message: import_zod.z.string(),
+      details: import_zod.z.unknown().optional()
+    })
+  })
+});
+var PermissionRequestedEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("permission.requested"),
+  timestamp: import_zod.z.number(),
+  sessionId: import_zod.z.string(),
+  data: import_zod.z.object({
+    permissionId: import_zod.z.string(),
+    toolName: import_zod.z.string(),
+    toolUseId: import_zod.z.string(),
+    input: import_zod.z.record(import_zod.z.unknown()),
+    risk: import_zod.z.enum(["safe", "moderate", "dangerous"]),
+    message: import_zod.z.string(),
+    suggestedAction: import_zod.z.enum(["allow", "deny"]).optional(),
+    timeout: import_zod.z.number().optional()
+  })
+});
+var PermissionRespondedEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("permission.responded"),
+  timestamp: import_zod.z.number(),
+  sessionId: import_zod.z.string(),
+  data: import_zod.z.object({
+    permissionId: import_zod.z.string(),
+    decision: import_zod.z.enum(["allow", "deny", "allowAll"]),
+    remember: import_zod.z.boolean(),
+    scope: import_zod.z.enum(["session", "project", "global"]).optional()
+  })
+});
+var PermissionTimeoutEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("permission.timeout"),
+  timestamp: import_zod.z.number(),
+  sessionId: import_zod.z.string(),
+  data: import_zod.z.object({
+    permissionId: import_zod.z.string(),
+    toolName: import_zod.z.string(),
+    defaultAction: import_zod.z.enum(["allow", "deny"])
+  })
+});
+var ErrorEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("error"),
+  timestamp: import_zod.z.number(),
+  sessionId: import_zod.z.string().optional(),
+  data: import_zod.z.object({
+    code: import_zod.z.string(),
+    message: import_zod.z.string(),
+    details: import_zod.z.unknown().optional(),
+    recoverable: import_zod.z.boolean(),
+    suggestedAction: import_zod.z.string().optional()
+  })
+});
+var ErrorStreamEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("error.stream"),
+  timestamp: import_zod.z.number(),
+  data: import_zod.z.object({
+    reason: import_zod.z.enum(["timeout", "aborted", "network", "server"]),
+    message: import_zod.z.string(),
+    retryable: import_zod.z.boolean(),
+    retryAfter: import_zod.z.number().optional()
+  })
+});
+var SSEReplayEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("sse.replay"),
+  timestamp: import_zod.z.number(),
+  data: import_zod.z.object({
+    replayCount: import_zod.z.number(),
+    replayGapCount: import_zod.z.number(),
+    lastEventId: import_zod.z.string(),
+    firstReplayId: import_zod.z.string().nullable().optional(),
+    lastReplayId: import_zod.z.string().nullable().optional()
+  })
+});
+var SSEReplayGapEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("sse.replay_gap"),
+  timestamp: import_zod.z.number(),
+  data: import_zod.z.object({
+    lastEventId: import_zod.z.string(),
+    reason: import_zod.z.enum(["last_event_not_found", "buffer_evicted"])
+  })
+});
+var SSEDedupEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("sse.dedup"),
+  timestamp: import_zod.z.number(),
+  data: import_zod.z.object({
+    duplicateCount: import_zod.z.number(),
+    totalSeen: import_zod.z.number(),
+    windowSize: import_zod.z.number()
+  })
+});
+var PybSSEEventSchema = import_zod.z.discriminatedUnion("type", [
+  ServerConnectedEventSchema,
+  ServerHeartbeatEventSchema,
+  ServerStatusEventSchema,
+  SessionCreatedEventSchema,
+  SessionUpdatedEventSchema,
+  SessionDeletedEventSchema,
+  MessageCreatedEventSchema,
+  MessageUpdatedEventSchema,
+  MessageCompletedEventSchema,
+  RequestStartedEventSchema,
+  RequestCompletedEventSchema,
+  ToolStartedEventSchema,
+  ToolProgressEventSchema,
+  ToolCompletedEventSchema,
+  ToolErrorEventSchema,
+  PermissionRequestedEventSchema,
+  PermissionRespondedEventSchema,
+  PermissionTimeoutEventSchema,
+  ErrorEventSchema,
+  ErrorStreamEventSchema,
+  SSEReplayEventSchema,
+  SSEReplayGapEventSchema,
+  SSEDedupEventSchema
+]);
+
+// src/client.ts
+var PybClient = class {
+  baseUrl;
+  timeout;
+  headers;
+  session;
+  mcp;
+  tool;
+  config;
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl ?? "http://localhost:4096/v1";
+    this.timeout = config.timeout ?? 12e4;
+    this.headers = {
+      "Content-Type": "application/json",
+      ...config.headers
+    };
+    this.session = {
+      create: (request = {}) => this.createSessionRequest(request),
+      list: (params) => this.listSessionsRequest(params),
+      get: (sessionId) => this.getSessionRequest(sessionId),
+      update: (sessionId, updates) => this.updateSessionRequest(sessionId, updates),
+      delete: (sessionId) => this.deleteSessionRequest(sessionId),
+      prompt: (sessionId, request) => this.sendPromptRequest(sessionId, request),
+      abort: (sessionId) => this.abortRequestRequest(sessionId),
+      messages: (sessionId, params) => this.getMessagesRequest(sessionId, params)
+    };
+    this.mcp = {
+      list: () => this.listMCPServersRequest(),
+      connect: (serverName) => this.connectMCPServerRequest(serverName),
+      disconnect: (serverName) => this.disconnectMCPServerRequest(serverName)
+    };
+    this.tool = {
+      list: () => this.listToolsRequest(),
+      execute: (toolName, input, options) => this.executeToolRequest(toolName, input, options)
+    };
+    this.config = {
+      get: () => this.getConfigRequest(),
+      update: (nextConfig) => this.updateConfigRequest(nextConfig)
+    };
+  }
+  // ============================================================
+  // Health API
+  // ============================================================
+  async getHealth() {
+    const response = await this.fetch("/health");
+    return response.json();
+  }
+  // ============================================================
+  // Session API
+  // ============================================================
+  async createSessionRequest(request = {}) {
+    const response = await this.fetch("/sessions", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+    const result = await response.json();
+    return result.data;
+  }
+  async listSessionsRequest(params) {
+    const searchParams = new URLSearchParams();
+    if (params?.page) searchParams.set("page", String(params.page));
+    if (params?.limit) searchParams.set("limit", String(params.limit));
+    if (params?.status) searchParams.set("status", params.status);
+    const query = searchParams.toString();
+    const response = await this.fetch(`/sessions${query ? `?${query}` : ""}`);
+    const result = await response.json();
+    return result.data;
+  }
+  async getSessionRequest(sessionId) {
+    const response = await this.fetch(`/sessions/${sessionId}`);
+    const result = await response.json();
+    return result.data;
+  }
+  async updateSessionRequest(sessionId, updates) {
+    const response = await this.fetch(`/sessions/${sessionId}`, {
+      method: "PATCH",
+      body: JSON.stringify(updates)
+    });
+    const result = await response.json();
+    return result.data;
+  }
+  async deleteSessionRequest(sessionId) {
+    await this.fetch(`/sessions/${sessionId}`, { method: "DELETE" });
+  }
+  // ============================================================
+  // Message API
+  // ============================================================
+  async sendPromptRequest(sessionId, request) {
+    const response = await this.fetch(`/sessions/${sessionId}/prompt`, {
+      method: "POST",
+      body: JSON.stringify({ ...request, options: { stream: false, ...request.options } })
+    });
+    const result = await response.json();
+    return result.data;
+  }
+  async abortRequestRequest(sessionId) {
+    const response = await this.fetch(`/sessions/${sessionId}/abort`, {
+      method: "POST"
+    });
+    const result = await response.json();
+    return result.data;
+  }
+  async getMessagesRequest(sessionId, params) {
+    const searchParams = new URLSearchParams();
+    if (params?.after) searchParams.set("after", params.after);
+    if (params?.before) searchParams.set("before", params.before);
+    if (params?.limit) searchParams.set("limit", String(params.limit));
+    const query = searchParams.toString();
+    const response = await this.fetch(`/sessions/${sessionId}/messages${query ? `?${query}` : ""}`);
+    const result = await response.json();
+    return result.data;
+  }
+  // ============================================================
+  // Permission API
+  // ============================================================
+  async respondToPermission(permissionId, request) {
+    const response = await this.fetch(`/permissions/${permissionId}/respond`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+    const result = await response.json();
+    return result.data;
+  }
+  async getPendingPermissions(sessionId) {
+    const searchParams = sessionId ? `?sessionId=${sessionId}` : "";
+    const response = await this.fetch(`/permissions/pending${searchParams}`);
+    const result = await response.json();
+    return result.data;
+  }
+  // ============================================================
+  // Tool API
+  // ============================================================
+  async listToolsRequest() {
+    const response = await this.fetch("/tools");
+    const result = await response.json();
+    return result.data;
+  }
+  async executeToolRequest(toolName, input, options) {
+    const response = await this.fetch(`/tools/${toolName}/execute`, {
+      method: "POST",
+      body: JSON.stringify({ input, options })
+    });
+    const result = await response.json();
+    return result.data;
+  }
+  // ============================================================
+  // Config API
+  // ============================================================
+  async getConfigRequest() {
+    const response = await this.fetch("/config");
+    const result = await response.json();
+    return result.data;
+  }
+  async updateConfigRequest(config) {
+    const response = await this.fetch("/config", {
+      method: "PUT",
+      body: JSON.stringify(config)
+    });
+    const result = await response.json();
+    return result.data;
+  }
+  // ============================================================
+  // MCP API
+  // ============================================================
+  async listMCPServersRequest() {
+    const response = await this.fetch("/mcp/servers");
+    const result = await response.json();
+    return result.data;
+  }
+  async connectMCPServerRequest(serverName) {
+    const response = await this.fetch(`/mcp/servers/${serverName}/connect`, {
+      method: "POST"
+    });
+    const result = await response.json();
+    return result.data;
+  }
+  async disconnectMCPServerRequest(serverName) {
+    await this.fetch(`/mcp/servers/${serverName}/disconnect`, {
+      method: "POST"
+    });
+  }
+  // ============================================================
+  // Internal
+  // ============================================================
+  async fetch(path, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          ...this.headers,
+          ...options.headers || {}
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new PybAPIError(
+          error.error?.code ?? "UNKNOWN_ERROR",
+          error.error?.message ?? `HTTP ${response.status}`,
+          error.error?.details
+        );
+      }
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+var PybAPIError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "PybAPIError";
+  }
+};
+
+// src/sse.ts
+var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
+var DEFAULT_FIRST_EVENT_TIMEOUT_MS = 15e3;
+var DEFAULT_CHUNK_TIMEOUT_MS = 3e4;
+var DEFAULT_RECONNECT_BASE_MS = 3e3;
+var DEFAULT_RECONNECT_MAX_MS = 3e4;
+var DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+var DEFAULT_DEDUP_WINDOW_SIZE = 200;
+var EventDeduplicator = class {
+  seen = /* @__PURE__ */ new Map();
+  duplicateCount = 0;
+  windowSize;
+  constructor(windowSize = DEFAULT_DEDUP_WINDOW_SIZE) {
+    this.windowSize = windowSize;
+  }
+  isDuplicate(eventId) {
+    return this.seen.has(eventId);
+  }
+  markSeen(eventId) {
+    if (this.seen.has(eventId)) {
+      this.duplicateCount++;
+      return;
+    }
+    this.seen.set(eventId, Date.now());
+    if (this.seen.size > this.windowSize) {
+      const oldest = this.seen.keys().next().value;
+      if (oldest) {
+        this.seen.delete(oldest);
+      }
+    }
+  }
+  getStats() {
+    return {
+      totalSeen: this.seen.size,
+      duplicateCount: this.duplicateCount,
+      windowSize: this.windowSize
+    };
+  }
+};
+function readPositiveInteger(value) {
+  const parsed = Number(value);
+  if (Number.isFinite(parsed) && parsed > 0) {
+    return Math.floor(parsed);
+  }
+  return void 0;
+}
+function resolveSSEClientRuntimeConfig(input) {
+  const env = input.env ?? process.env;
+  const options = input.options ?? {};
+  const reconnectBaseMs = readPositiveInteger(options.reconnectBaseMs ?? options.reconnectInterval) ?? readPositiveInteger(env.PYB_SSE_RECONNECT_BASE_MS) ?? DEFAULT_RECONNECT_BASE_MS;
+  const reconnectMaxMs = readPositiveInteger(options.reconnectMaxMs) ?? readPositiveInteger(env.PYB_SSE_RECONNECT_MAX_MS) ?? DEFAULT_RECONNECT_MAX_MS;
+  const maxReconnectAttempts = readPositiveInteger(options.maxReconnectAttempts) ?? readPositiveInteger(env.PYB_SSE_MAX_RECONNECT_ATTEMPTS) ?? DEFAULT_MAX_RECONNECT_ATTEMPTS;
+  return {
+    connectTimeoutMs: readPositiveInteger(options.connectTimeoutMs) ?? readPositiveInteger(env.PYB_SSE_CONNECT_TIMEOUT_MS) ?? DEFAULT_CONNECT_TIMEOUT_MS,
+    firstEventTimeoutMs: readPositiveInteger(options.firstEventTimeoutMs) ?? readPositiveInteger(env.PYB_SSE_FIRST_EVENT_TIMEOUT_MS) ?? DEFAULT_FIRST_EVENT_TIMEOUT_MS,
+    chunkTimeoutMs: readPositiveInteger(options.chunkTimeoutMs) ?? readPositiveInteger(env.PYB_SSE_CHUNK_TIMEOUT_MS) ?? DEFAULT_CHUNK_TIMEOUT_MS,
+    reconnectBaseMs,
+    reconnectMaxMs: Math.max(reconnectMaxMs, reconnectBaseMs),
+    maxReconnectAttempts
+  };
+}
+var SSEClient = class {
+  baseUrl;
+  reconnectBaseMs;
+  reconnectMaxMs;
+  maxReconnectAttempts;
+  connectTimeoutMs;
+  firstEventTimeoutMs;
+  chunkTimeoutMs;
+  sessionIds;
+  eventTypes;
+  lastReceivedEventId;
+  deduplicator;
+  replayCount = 0;
+  replayGapCount = 0;
+  duplicateCount = 0;
+  eventSource = null;
+  callbacks = /* @__PURE__ */ new Map();
+  wildcardCallbacks = /* @__PURE__ */ new Set();
+  reconnectAttempts = 0;
+  reconnectDelayMs = 0;
+  lastDisconnectReason = null;
+  lastEventAt = null;
+  isConnecting = false;
+  shouldReconnect = true;
+  hasReceivedFirstEvent = false;
+  connectTimeoutTimer = null;
+  firstEventTimeoutTimer = null;
+  chunkTimeoutTimer = null;
+  constructor(options = {}) {
+    const runtimeConfig = resolveSSEClientRuntimeConfig({
+      options,
+      env: process.env
+    });
+    this.baseUrl = options.baseUrl ?? "http://localhost:4096/v1";
+    this.reconnectBaseMs = runtimeConfig.reconnectBaseMs;
+    this.reconnectMaxMs = runtimeConfig.reconnectMaxMs;
+    this.maxReconnectAttempts = runtimeConfig.maxReconnectAttempts;
+    this.connectTimeoutMs = runtimeConfig.connectTimeoutMs;
+    this.firstEventTimeoutMs = runtimeConfig.firstEventTimeoutMs;
+    this.chunkTimeoutMs = runtimeConfig.chunkTimeoutMs;
+    this.sessionIds = options.sessionIds;
+    this.eventTypes = options.eventTypes;
+    this.lastReceivedEventId = options.lastEventId ?? null;
+    this.deduplicator = new EventDeduplicator(options.dedupWindowSize ?? DEFAULT_DEDUP_WINDOW_SIZE);
+  }
+  connect() {
+    if (this.eventSource || this.isConnecting) {
+      return;
+    }
+    this.isConnecting = true;
+    this.shouldReconnect = true;
+    this.hasReceivedFirstEvent = false;
+    const params = new URLSearchParams();
+    if (this.sessionIds?.length) {
+      params.set("sessionIds", this.sessionIds.join(","));
+    }
+    if (this.eventTypes?.length) {
+      params.set("eventTypes", this.eventTypes.join(","));
+    }
+    const url = this.buildEventsUrl(params);
+    try {
+      this.eventSource = new EventSource(url);
+      this.setupConnectTimeout();
+      this.eventSource.onopen = () => {
+        this.isConnecting = false;
+        this.reconnectAttempts = 0;
+        this.clearConnectTimeout();
+        this.setupFirstEventTimeout();
+        this.emitDiagnosticEvent("connected");
+      };
+      this.eventSource.onerror = () => {
+        this.handleDisconnect("event_source_error");
+      };
+      this.eventSource.onmessage = (event) => {
+        this.handleMessage(event);
+      };
+      const eventTypes = [
+        "server.connected",
+        "server.heartbeat",
+        "server.status",
+        "session.created",
+        "session.updated",
+        "session.deleted",
+        "message.created",
+        "message.updated",
+        "message.completed",
+        "request.started",
+        "request.completed",
+        "tool.started",
+        "tool.progress",
+        "tool.completed",
+        "tool.error",
+        "permission.requested",
+        "permission.responded",
+        "permission.timeout",
+        "mcp.status",
+        "error",
+        "error.stream",
+        "sse.replay",
+        "sse.replay_gap",
+        "sse.dedup"
+      ];
+      for (const eventType of eventTypes) {
+        this.eventSource.addEventListener(eventType, (event) => {
+          this.handleMessage(event);
+        });
+      }
+    } catch (error) {
+      this.isConnecting = false;
+      this.attemptReconnect();
+    }
+  }
+  disconnect() {
+    this.shouldReconnect = false;
+    this.clearAllTimeouts();
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+  }
+  subscribe(eventType, callback) {
+    if (!this.callbacks.has(eventType)) {
+      this.callbacks.set(eventType, /* @__PURE__ */ new Set());
+    }
+    this.callbacks.get(eventType).add(callback);
+    return () => {
+      this.callbacks.get(eventType)?.delete(callback);
+    };
+  }
+  subscribeAll(callback) {
+    this.wildcardCallbacks.add(callback);
+    return () => {
+      this.wildcardCallbacks.delete(callback);
+    };
+  }
+  subscribeFiltered(filter, callback) {
+    const wrapped = (event) => {
+      if (filter.sessionId) {
+        const sessionId = "sessionId" in event && typeof event.sessionId === "string" ? event.sessionId : void 0;
+        if (sessionId !== filter.sessionId) {
+          return;
+        }
+      }
+      if (filter.type) {
+        if (Array.isArray(filter.type)) {
+          if (!filter.type.includes(event.type)) {
+            return;
+          }
+        } else if (event.type !== filter.type) {
+          return;
+        }
+      }
+      if (filter.predicate && !filter.predicate(event)) {
+        return;
+      }
+      callback(event);
+    };
+    return this.subscribeAll(wrapped);
+  }
+  handleMessage(event) {
+    try {
+      const rawData = JSON.parse(event.data);
+      const rawEventId = typeof rawData?.id === "string" ? rawData.id : null;
+      if (rawEventId) {
+        if (this.deduplicator.isDuplicate(rawEventId)) {
+          this.duplicateCount++;
+          this.emitDedupDiagnosticEvent();
+          return;
+        }
+        this.deduplicator.markSeen(rawEventId);
+        this.lastReceivedEventId = rawEventId;
+      }
+      const parseResult = PybSSEEventSchema.safeParse(rawData);
+      if (parseResult.success) {
+        this.lastEventAt = Date.now();
+        if (!this.hasReceivedFirstEvent) {
+          this.hasReceivedFirstEvent = true;
+          this.clearFirstEventTimeout();
+        }
+        this.resetChunkTimeout();
+        const typedEvent = parseResult.data;
+        if (typedEvent.type === "sse.replay") {
+          const replayCount = typedEvent.data?.replayCount;
+          const replayGapCount = typedEvent.data?.replayGapCount;
+          if (typeof replayCount === "number") this.replayCount = replayCount;
+          if (typeof replayGapCount === "number") this.replayGapCount = replayGapCount;
+        }
+        if (typedEvent.type === "sse.replay_gap") {
+          this.replayGapCount++;
+        }
+        this.emit(typedEvent.type, typedEvent);
+      }
+    } catch (error) {
+      console.error("Failed to parse SSE event:", error);
+    }
+  }
+  emit(eventType, event) {
+    const callbacks = this.callbacks.get(eventType);
+    if (callbacks) {
+      for (const callback of callbacks) {
+        try {
+          callback(event);
+        } catch (error) {
+          console.error("Error in SSE callback:", error);
+        }
+      }
+    }
+    for (const callback of this.wildcardCallbacks) {
+      try {
+        callback(event);
+      } catch (error) {
+        console.error("Error in SSE wildcard callback:", error);
+      }
+    }
+  }
+  handleDisconnect(reason) {
+    this.eventSource?.close();
+    this.eventSource = null;
+    this.isConnecting = false;
+    this.lastDisconnectReason = reason;
+    this.clearAllTimeouts();
+    this.emitDiagnosticEvent("disconnected");
+    if (this.shouldReconnect) {
+      this.attemptReconnect();
+    }
+  }
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error("Max reconnect attempts reached");
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      this.reconnectBaseMs * Math.pow(2, this.reconnectAttempts - 1),
+      this.reconnectMaxMs
+    );
+    this.reconnectDelayMs = delay;
+    this.emitDiagnosticEvent("reconnect_scheduled");
+    setTimeout(() => {
+      if (this.shouldReconnect) {
+        this.connect();
+      }
+    }, delay);
+  }
+  setupConnectTimeout() {
+    this.clearConnectTimeout();
+    this.connectTimeoutTimer = setTimeout(() => {
+      this.handleDisconnect("connect_timeout");
+    }, this.connectTimeoutMs);
+  }
+  setupFirstEventTimeout() {
+    this.clearFirstEventTimeout();
+    this.firstEventTimeoutTimer = setTimeout(() => {
+      this.handleDisconnect("first_event_timeout");
+    }, this.firstEventTimeoutMs);
+  }
+  resetChunkTimeout() {
+    this.clearChunkTimeout();
+    this.chunkTimeoutTimer = setTimeout(() => {
+      this.handleDisconnect("chunk_timeout");
+    }, this.chunkTimeoutMs);
+  }
+  clearConnectTimeout() {
+    if (this.connectTimeoutTimer) {
+      clearTimeout(this.connectTimeoutTimer);
+      this.connectTimeoutTimer = null;
+    }
+  }
+  clearFirstEventTimeout() {
+    if (this.firstEventTimeoutTimer) {
+      clearTimeout(this.firstEventTimeoutTimer);
+      this.firstEventTimeoutTimer = null;
+    }
+  }
+  clearChunkTimeout() {
+    if (this.chunkTimeoutTimer) {
+      clearTimeout(this.chunkTimeoutTimer);
+      this.chunkTimeoutTimer = null;
+    }
+  }
+  clearAllTimeouts() {
+    this.clearConnectTimeout();
+    this.clearFirstEventTimeout();
+    this.clearChunkTimeout();
+  }
+  emitDiagnosticEvent(phase) {
+    this.emit("sse.diagnostic", {
+      type: "sse.diagnostic",
+      timestamp: Date.now(),
+      data: {
+        phase,
+        reconnectAttempts: this.reconnectAttempts,
+        reconnectDelayMs: this.reconnectDelayMs,
+        lastDisconnectReason: this.lastDisconnectReason,
+        lastEventAt: this.lastEventAt
+      }
+    });
+  }
+  emitDedupDiagnosticEvent() {
+    const stats = this.deduplicator.getStats();
+    this.emit("sse.dedup", {
+      type: "sse.dedup",
+      timestamp: Date.now(),
+      data: {
+        duplicateCount: this.duplicateCount,
+        totalSeen: stats.totalSeen,
+        windowSize: stats.windowSize
+      }
+    });
+  }
+  buildEventsUrl(params) {
+    if (this.lastReceivedEventId) {
+      params.set("lastEventId", this.lastReceivedEventId);
+    }
+    return `${this.baseUrl}/events${params.toString() ? `?${params}` : ""}`;
+  }
+  isConnected() {
+    return this.eventSource?.readyState === EventSource.OPEN;
+  }
+  getReconnectAttempts() {
+    return this.reconnectAttempts;
+  }
+  getDiagnostics() {
+    return {
+      reconnectAttempts: this.reconnectAttempts,
+      reconnectDelayMs: this.reconnectDelayMs,
+      lastDisconnectReason: this.lastDisconnectReason,
+      lastEventAt: this.lastEventAt
+    };
+  }
+  getResumptionDiagnostics() {
+    return {
+      lastReceivedEventId: this.lastReceivedEventId,
+      replayCount: this.replayCount,
+      replayGapCount: this.replayGapCount,
+      duplicateCount: this.duplicateCount
+    };
+  }
+};
+function createSSEClient(options) {
+  return new SSEClient(options);
+}
+
+// src/v2/message.ts
+var import_zod2 = require("zod");
+var V2MessageContentTextSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("text"),
+  text: import_zod2.z.string()
+});
+var V2MessageSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  role: import_zod2.z.enum(["user", "assistant", "system"]),
+  channel: import_zod2.z.enum(["runtime", "protocol"]),
+  content: import_zod2.z.array(V2MessageContentTextSchema).min(1),
+  finishReason: import_zod2.z.enum(["end_turn", "tool_calls", "max_tokens", "unknown"]),
+  timestamp: import_zod2.z.number().int()
+});
+function normalizeTextContent(content) {
+  if (Array.isArray(content)) {
+    const textParts = content.filter((item) => typeof item === "object" && item !== null).map((item) => item.type === "text" && typeof item.text === "string" ? item.text : "").filter(Boolean);
+    if (textParts.length > 0) return textParts.join("\n");
+  }
+  if (typeof content === "string") return content;
+  return "";
+}
+function coerceFinishReason(value) {
+  if (value === "end_turn" || value === "tool_calls" || value === "max_tokens") return value;
+  return "unknown";
+}
+function mapRuntimeMessageToV2(message) {
+  const text = normalizeTextContent(message?.message?.content);
+  return {
+    id: String(message?.uuid ?? message?.message?.id ?? `runtime-${Date.now()}`),
+    role: message?.type === "assistant" ? "assistant" : message?.type === "user" ? "user" : "system",
+    channel: "runtime",
+    content: [{ type: "text", text: text || `[${String(message?.type ?? "runtime")}]` }],
+    finishReason: coerceFinishReason(message?.finish ?? message?.message?.stop_reason),
+    timestamp: Date.now()
+  };
+}
+function mapV1MessageToV2(message) {
+  const text = normalizeTextContent(message?.content);
+  const role = message?.role === "assistant" || message?.role === "user" ? message.role : "system";
+  return {
+    id: String(message?.id ?? `protocol-${Date.now()}`),
+    role,
+    channel: "protocol",
+    content: [{ type: "text", text: text || "[protocol-message]" }],
+    finishReason: "unknown",
+    timestamp: Number.isFinite(message?.timestamp) ? Number(message.timestamp) : Date.now()
+  };
+}
+function validateV2Message(message) {
+  return V2MessageSchema.safeParse(message);
+}
+
+// src/v2/toolUseContext.ts
+var import_zod3 = require("zod");
+var PermissionModeSchema = import_zod3.z.enum([
+  "default",
+  "acceptEdits",
+  "plan",
+  "bypassPermissions",
+  "dontAsk"
+]);
+var V2ToolUseContextSchema = import_zod3.z.object({
+  requestId: import_zod3.z.string(),
+  messageId: import_zod3.z.string().optional(),
+  abortController: import_zod3.z.any(),
+  readFileTimestamps: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number()),
+  options: import_zod3.z.object({
+    permissionMode: PermissionModeSchema,
+    typedSessionWriteEnabled: import_zod3.z.boolean(),
+    compactionBoundaryEnabled: import_zod3.z.boolean(),
+    toolOutputLifecycleEnabled: import_zod3.z.boolean(),
+    singleFactLayerReadEnabled: import_zod3.z.boolean(),
+    tools: import_zod3.z.array(import_zod3.z.any()).optional(),
+    commands: import_zod3.z.array(import_zod3.z.any()).optional(),
+    verbose: import_zod3.z.boolean().optional(),
+    safeMode: import_zod3.z.boolean().optional()
+  })
+});
+function resolvePermissionMode(skipPermissions) {
+  return skipPermissions ? "bypassPermissions" : "default";
+}
+function buildV2ToolUseContextFromPromptRequest(input) {
+  return {
+    requestId: input.requestId,
+    messageId: input.messageId,
+    abortController: new AbortController(),
+    readFileTimestamps: {},
+    options: {
+      permissionMode: resolvePermissionMode(input.promptRequest?.options?.skipPermissions),
+      typedSessionWriteEnabled: true,
+      compactionBoundaryEnabled: false,
+      toolOutputLifecycleEnabled: false,
+      singleFactLayerReadEnabled: true
+    }
+  };
+}
+function isToolAutoExecutableInContext(input) {
+  if (input.requiresUserInteraction) return false;
+  if (input.context.options.permissionMode === "dontAsk") return false;
+  return true;
+}
+function validateV2ToolUseContext(context) {
+  return V2ToolUseContextSchema.safeParse(context);
+}
+
+// src/v2/session.ts
+var import_zod4 = require("zod");
+var V2SessionStatusSchema = import_zod4.z.enum([
+  "idle",
+  "running",
+  "blocked",
+  "errored",
+  "closed"
+]);
+var V2RequestStatusSchema = import_zod4.z.enum([
+  "idle",
+  "running",
+  "interrupted",
+  "errored",
+  "closed"
+]);
+var V2SessionSchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  status: V2SessionStatusSchema,
+  requestStatus: V2RequestStatusSchema,
+  messageCount: import_zod4.z.number().int().nonnegative(),
+  createdAt: import_zod4.z.number().int(),
+  updatedAt: import_zod4.z.number().int(),
+  config: import_zod4.z.object({
+    model: import_zod4.z.string(),
+    agent: import_zod4.z.string(),
+    outputStyle: import_zod4.z.string()
+  })
+});
+var transitionTable = {
+  idle: ["idle", "running", "closed", "errored"],
+  running: ["running", "idle", "blocked", "errored", "closed"],
+  blocked: ["blocked", "running", "idle", "errored", "closed"],
+  errored: ["errored", "idle", "closed"],
+  closed: ["closed"]
+};
+function canTransitionV2SessionStatus(from, to) {
+  return transitionTable[from].includes(to);
+}
+function mapRuntimeSessionStatusToV2(status) {
+  if (status === "processing") return "running";
+  if (status === "waiting_permission") return "blocked";
+  if (status === "error") return "errored";
+  return "idle";
+}
+function mapV1SessionStatusToV2(status) {
+  if (status === "active") return "running";
+  if (status === "archived") return "closed";
+  return "idle";
+}
+function validateV2Session(session) {
+  return V2SessionSchema.safeParse(session);
+}
+
+// src/v2/dualTrackEvaluation.ts
+var import_zod5 = require("zod");
+var DualTrackRawStatsSchema = import_zod5.z.object({
+  totalRequests: import_zod5.z.number().int().nonnegative(),
+  v1SuccessCount: import_zod5.z.number().int().nonnegative(),
+  v2SuccessCount: import_zod5.z.number().int().nonnegative(),
+  diffCount: import_zod5.z.number().int().nonnegative(),
+  unmappableCount: import_zod5.z.number().int().nonnegative(),
+  rollbackTriggerCount: import_zod5.z.number().int().nonnegative()
+});
+var DualTrackMetricsSchema = import_zod5.z.object({
+  totalRequests: import_zod5.z.number().int().nonnegative(),
+  successRate: import_zod5.z.number().min(0).max(1),
+  diffRate: import_zod5.z.number().min(0).max(1),
+  unmappableRate: import_zod5.z.number().min(0).max(1),
+  rollbackTriggerCount: import_zod5.z.number().int().nonnegative()
+});
+var DualTrackThresholdsSchema = import_zod5.z.object({
+  minSuccessRate: import_zod5.z.number().min(0).max(1),
+  maxDiffRate: import_zod5.z.number().min(0).max(1),
+  maxUnmappableRate: import_zod5.z.number().min(0).max(1),
+  maxRollbackTriggers: import_zod5.z.number().int().nonnegative()
+});
+function buildDefaultDualTrackThresholds() {
+  return {
+    minSuccessRate: 0.99,
+    maxDiffRate: 0.01,
+    maxUnmappableRate: 0.01,
+    maxRollbackTriggers: 0
+  };
+}
+function ratio(count, total) {
+  if (total <= 0) return 0;
+  return Number((count / total).toFixed(6));
+}
+function evaluateDualTrackMetrics(input) {
+  const stats = DualTrackRawStatsSchema.parse(input);
+  const effectiveSuccessCount = Math.min(stats.v1SuccessCount, stats.v2SuccessCount);
+  return {
+    totalRequests: stats.totalRequests,
+    successRate: ratio(effectiveSuccessCount, stats.totalRequests),
+    diffRate: ratio(stats.diffCount, stats.totalRequests),
+    unmappableRate: ratio(stats.unmappableCount, stats.totalRequests),
+    rollbackTriggerCount: stats.rollbackTriggerCount
+  };
+}
+function evaluateV1DeprecationReadiness(metricsInput, thresholdsInput) {
+  const metrics = DualTrackMetricsSchema.parse(metricsInput);
+  const thresholds = DualTrackThresholdsSchema.parse(thresholdsInput);
+  const failedChecks = [];
+  if (metrics.successRate < thresholds.minSuccessRate) failedChecks.push("minSuccessRate");
+  if (metrics.diffRate > thresholds.maxDiffRate) failedChecks.push("maxDiffRate");
+  if (metrics.unmappableRate > thresholds.maxUnmappableRate) failedChecks.push("maxUnmappableRate");
+  if (metrics.rollbackTriggerCount > thresholds.maxRollbackTriggers) {
+    failedChecks.push("maxRollbackTriggers");
+  }
+  return {
+    ready: failedChecks.length === 0,
+    failedChecks
+  };
+}
+
+// src/v2/runtimeSession.types.ts
+var import_zod6 = require("zod");
+var RuntimeSessionStatusSchema = import_zod6.z.enum(["pending", "running", "closed"]);
+var RuntimeSessionInputSchema = import_zod6.z.object({
+  message: import_zod6.z.string().min(1),
+  attachments: import_zod6.z.array(import_zod6.z.record(import_zod6.z.unknown())).optional()
+});
+var RuntimeSessionEventSchema = import_zod6.z.discriminatedUnion("type", [
+  import_zod6.z.object({
+    type: import_zod6.z.literal("message.created"),
+    data: import_zod6.z.record(import_zod6.z.unknown())
+  }),
+  import_zod6.z.object({
+    type: import_zod6.z.literal("message.updated"),
+    data: import_zod6.z.record(import_zod6.z.unknown()),
+    delta: import_zod6.z.string().optional()
+  }),
+  import_zod6.z.object({
+    type: import_zod6.z.literal("tool.started"),
+    data: import_zod6.z.record(import_zod6.z.unknown())
+  }),
+  import_zod6.z.object({
+    type: import_zod6.z.literal("tool.completed"),
+    data: import_zod6.z.record(import_zod6.z.unknown())
+  }),
+  import_zod6.z.object({
+    type: import_zod6.z.literal("request.completed"),
+    data: import_zod6.z.record(import_zod6.z.unknown())
+  }),
+  import_zod6.z.object({
+    type: import_zod6.z.literal("error"),
+    data: import_zod6.z.record(import_zod6.z.unknown())
+  }),
+  import_zod6.z.object({
+    type: import_zod6.z.literal("permission.decision"),
+    data: import_zod6.z.object({
+      decision: import_zod6.z.enum(["allow", "ask", "deny"]),
+      reason: import_zod6.z.string(),
+      source: import_zod6.z.enum(["callback", "policy", "default"]),
+      tool: import_zod6.z.string(),
+      requestId: import_zod6.z.string()
+    })
+  })
+]);
+
+// src/v2/runtimePermission.ts
+var KNOWN_PERMISSION_MODES = [
+  "default",
+  "acceptEdits",
+  "plan",
+  "bypassPermissions",
+  "dontAsk"
+];
+function resolvePermissionModeForSdk(input) {
+  if (typeof input === "string" && KNOWN_PERMISSION_MODES.includes(input)) {
+    return { permissionMode: input };
+  }
+  if (typeof input === "undefined") {
+    return { permissionMode: "default" };
+  }
+  return {
+    permissionMode: "default",
+    invalidPermissionMode: input
+  };
+}
+function createRuntimePermissionContextForSession(input) {
+  const modeResult = resolvePermissionModeForSdk(input.permissionPolicy?.permissionMode);
+  const candidate = input.permissionPolicy?.toolPermissionContext ?? input.toolPermissionContext;
+  const baseline = createDefaultToolPermissionContextForSdk({
+    sessionId: input.sessionId,
+    requestId: input.requestId,
+    permissionMode: modeResult.permissionMode
+  });
+  const metadata = {
+    ...isPlainObject(candidate?.metadata) ? candidate.metadata : {}
+  };
+  if (typeof modeResult.invalidPermissionMode !== "undefined") {
+    metadata.invalidPermissionMode = modeResult.invalidPermissionMode;
+  }
+  return {
+    sessionId: typeof candidate?.sessionId === "string" ? candidate.sessionId : baseline.sessionId,
+    requestId: typeof candidate?.requestId === "string" ? candidate.requestId : baseline.requestId,
+    permissionMode: modeResult.permissionMode,
+    cwd: typeof candidate?.cwd === "string" ? candidate.cwd : baseline.cwd,
+    metadata: Object.keys(metadata).length > 0 ? metadata : baseline.metadata
+  };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function createDefaultToolPermissionContextForSdk(input) {
+  return {
+    sessionId: input.sessionId,
+    requestId: input.requestId,
+    permissionMode: input.permissionMode ?? "default",
+    cwd: input.cwd,
+    metadata: input.metadata
+  };
+}
+function resolvePermissionDecision(input) {
+  const callbackDecision = ensureValidDecision(input.callbackDecision, "callback");
+  if (callbackDecision) return callbackDecision;
+  const policyDecision = ensureValidDecision(input.policyDecision, "policy");
+  if (policyDecision) return policyDecision;
+  const defaultDecision = ensureValidDecision(input.defaultDecision, "default");
+  if (defaultDecision) return defaultDecision;
+  return {
+    decision: "deny",
+    reason: "default-deny-fallback",
+    source: "default"
+  };
+}
+function ensureValidDecision(decision, expectedSource) {
+  if (!decision) return null;
+  if (decision.source !== expectedSource) return null;
+  if (decision.decision !== "allow" && decision.decision !== "ask" && decision.decision !== "deny") {
+    return null;
+  }
+  return {
+    decision: decision.decision,
+    reason: typeof decision.reason === "string" ? decision.reason : "",
+    source: decision.source
+  };
+}
+
+// src/v2/runtimeEvent.types.ts
+var import_zod7 = require("zod");
+var RuntimeEventDomainSchema = import_zod7.z.enum([
+  "message",
+  "tool",
+  "permission",
+  "session",
+  "lifecycle"
+]);
+var RuntimeEventSchema = import_zod7.z.object({
+  domain: RuntimeEventDomainSchema,
+  type: import_zod7.z.string().min(1),
+  sessionId: import_zod7.z.string().min(1),
+  timestamp: import_zod7.z.number().finite(),
+  requestId: import_zod7.z.string().min(1).optional(),
+  data: import_zod7.z.record(import_zod7.z.unknown())
+});
+
+// src/v2/runtimeEventProjector.ts
+var RUNTIME_EVENT_MAPPING_RULES = {
+  "message.created": { domain: "message", type: "message.created" },
+  "message.updated": { domain: "message", type: "message.updated" },
+  "tool.started": { domain: "tool", type: "tool.started" },
+  "tool.progress": { domain: "tool", type: "tool.progress" },
+  "tool.completed": { domain: "tool", type: "tool.completed" },
+  "permission.decision": { domain: "permission", type: "permission.decision" },
+  "session.state.changed": { domain: "session", type: "session.state.changed" },
+  "session.completed": { domain: "session", type: "session.completed" },
+  "session.error": { domain: "session", type: "session.error" },
+  "request.completed": { domain: "session", type: "session.completed" },
+  error: { domain: "session", type: "session.error" },
+  "lifecycle.start-query": { domain: "lifecycle", type: "lifecycle.query.started" },
+  "lifecycle.start-step": { domain: "lifecycle", type: "lifecycle.step.started" },
+  "lifecycle.finish-step": { domain: "lifecycle", type: "lifecycle.step.finished" },
+  "lifecycle.finish-query": { domain: "lifecycle", type: "lifecycle.query.finished" }
+};
+var LEGACY_EVENT_MAPPING_RULES = {
+  "message.created": "message.created",
+  "message.updated": "message.updated",
+  "tool.started": "tool.started",
+  "tool.progress": "tool.progress",
+  "tool.completed": "tool.completed",
+  "permission.decision": "permission.decision",
+  "session.state.changed": "session.state.changed",
+  "session.completed": "request.completed",
+  "session.error": "error",
+  "lifecycle.query.started": "lifecycle.start-query",
+  "lifecycle.step.started": "lifecycle.start-step",
+  "lifecycle.step.finished": "lifecycle.finish-step",
+  "lifecycle.query.finished": "lifecycle.finish-query"
+};
+function getRuntimeEventMappingRules() {
+  return { ...RUNTIME_EVENT_MAPPING_RULES };
+}
+function projectLegacyEventToRuntimeEvent(input) {
+  const mappingRule = RUNTIME_EVENT_MAPPING_RULES[input.type];
+  const domain = mappingRule?.domain ?? "session";
+  const type = mappingRule?.type ?? "session.error";
+  return RuntimeEventSchema.parse({
+    domain,
+    type,
+    sessionId: input.sessionId,
+    requestId: input.requestId,
+    timestamp: input.timestamp ?? Date.now(),
+    data: input.data
+  });
+}
+function projectRuntimeEventToLegacyEvent(input) {
+  const legacyType = LEGACY_EVENT_MAPPING_RULES[input.type] ?? "error";
+  const data = { ...input.data };
+  if (legacyType === "request.completed" && typeof data.requestId === "undefined" && input.requestId) {
+    data.requestId = input.requestId;
+  }
+  return {
+    type: legacyType,
+    data
+  };
+}
+
+// src/v2/runtimeSession.ts
+var DEFAULT_PERMISSION_CALLBACK_TIMEOUT_MS = 1e3;
+var DefaultQuerySessionExecutor = class {
+  async *execute(_input) {
+  }
+};
+var DefaultToolResolver = class {
+  async resolve() {
+    return [];
+  }
+};
+var DefaultPermissionEvaluator = class {
+  async canUseTool() {
+    return {
+      decision: "allow",
+      reason: "default-allow",
+      source: "default"
+    };
+  }
+};
+var DefaultSessionEventPublisher = class {
+  publish() {
+  }
+};
+function createRuntimeSession(config) {
+  const querySessionExecutor = config.querySessionExecutor ?? new DefaultQuerySessionExecutor();
+  const toolResolver = config.toolResolver ?? new DefaultToolResolver();
+  const permissionEvaluator = config.permissionEvaluator ?? new DefaultPermissionEvaluator();
+  const sessionEventPublisher = config.sessionEventPublisher ?? new DefaultSessionEventPublisher();
+  let status = "pending";
+  let pendingInput = null;
+  const messages = (config.initialMessages ?? []).map(
+    (input) => RuntimeSessionInputSchema.parse(input)
+  );
+  let turnId = 0;
+  let abortController = new AbortController();
+  let closed = false;
+  let streamInProgress = false;
+  function ensureOpen() {
+    if (!closed) return;
+    throw new Error("RUNTIME_SESSION_CLOSED");
+  }
+  async function* executeTurn(mode) {
+    ensureOpen();
+    if (streamInProgress) throw new Error("RUNTIME_SESSION_TURN_IN_PROGRESS");
+    if (!pendingInput) throw new Error("RUNTIME_SESSION_INPUT_REQUIRED");
+    streamInProgress = true;
+    status = "running";
+    const input = pendingInput;
+    pendingInput = null;
+    const tools = await toolResolver.resolve();
+    const requestId = `${config.sessionId}-turn-${turnId}`;
+    const runtimePermissionContext = createRuntimePermissionContextForSession({
+      sessionId: config.sessionId,
+      requestId,
+      toolPermissionContext: config.toolPermissionContext,
+      permissionPolicy: config.permissionPolicy
+    });
+    const stream = querySessionExecutor.execute(input, {
+      abortSignal: abortController.signal,
+      sessionId: config.sessionId,
+      turnId,
+      tools,
+      messages: [...messages],
+      runtimeContext: config.runtimeContext,
+      toolPermissionContext: runtimePermissionContext,
+      canUseTool: async (payload) => {
+        const effectiveContext = payload.context ?? runtimePermissionContext;
+        const callbackDecision = await resolveCallbackDecision({
+          permissionPolicy: config.permissionPolicy,
+          payload: {
+            toolName: payload.toolName,
+            toolInput: payload.toolInput,
+            context: effectiveContext
+          },
+          timeoutMs: resolvePermissionCallbackTimeoutMs(config.permissionCallbackTimeoutMs)
+        });
+        const policyDecision = await resolvePolicyDecision({
+          permissionEvaluator,
+          payload: {
+            toolName: payload.toolName,
+            toolInput: payload.toolInput,
+            context: effectiveContext
+          }
+        });
+        const decision = resolvePermissionDecision({
+          callbackDecision,
+          policyDecision
+        });
+        await sessionEventPublisher.publish({
+          type: "permission.decision",
+          data: {
+            decision: decision.decision,
+            reason: decision.reason,
+            source: decision.source,
+            tool: payload.toolName,
+            requestId
+          }
+        });
+        return decision;
+      }
+    });
+    try {
+      for await (const event of stream) {
+        if (mode === "legacy") {
+          await sessionEventPublisher.publish(event);
+          yield event;
+          continue;
+        }
+        const projected = projectEventToRuntimeEvent({
+          event,
+          sessionId: config.sessionId,
+          requestId
+        });
+        await sessionEventPublisher.publish(projected);
+        yield projected;
+      }
+    } finally {
+      streamInProgress = false;
+      if (!closed) status = "pending";
+    }
+  }
+  return {
+    get status() {
+      return RuntimeSessionStatusSchema.parse(status);
+    },
+    send(input) {
+      ensureOpen();
+      if (streamInProgress) throw new Error("RUNTIME_SESSION_TURN_IN_PROGRESS");
+      if (pendingInput) throw new Error("RUNTIME_SESSION_INPUT_PENDING");
+      const parsed = RuntimeSessionInputSchema.parse(input);
+      if (abortController.signal.aborted) abortController = new AbortController();
+      pendingInput = parsed;
+      messages.push(parsed);
+      status = "pending";
+      turnId += 1;
+    },
+    async *stream() {
+      for await (const event of executeTurn("legacy")) {
+        yield event;
+      }
+    },
+    async *streamRuntimeEvents() {
+      for await (const event of executeTurn("runtime")) {
+        yield event;
+      }
+    },
+    interrupt() {
+      ensureOpen();
+      abortController.abort();
+      status = "pending";
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      abortController.abort();
+      status = "closed";
+      pendingInput = null;
+    }
+  };
+}
+function projectEventToRuntimeEvent(input) {
+  const eventRecord = input.event;
+  const data = isRecord(eventRecord.data) ? eventRecord.data : {};
+  const requestIdFromData = typeof data.requestId === "string" ? data.requestId : void 0;
+  const requestId = requestIdFromData ?? (typeof eventRecord.requestId === "string" ? eventRecord.requestId : void 0) ?? input.requestId;
+  const timestamp = typeof eventRecord.timestamp === "number" && Number.isFinite(eventRecord.timestamp) ? eventRecord.timestamp : void 0;
+  return projectLegacyEventToRuntimeEvent({
+    type: eventRecord.type,
+    sessionId: input.sessionId,
+    requestId,
+    timestamp,
+    data
+  });
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function resolvePermissionCallbackTimeoutMs(input) {
+  if (typeof input !== "number" || !Number.isFinite(input) || input < 0) {
+    return DEFAULT_PERMISSION_CALLBACK_TIMEOUT_MS;
+  }
+  return Math.floor(input);
+}
+async function resolveCallbackDecision(input) {
+  if (!input.permissionPolicy?.canUseTool) return null;
+  try {
+    const callbackPromise = Promise.resolve(input.permissionPolicy.canUseTool(input.payload));
+    return await runWithTimeout(callbackPromise, input.timeoutMs);
+  } catch {
+    return null;
+  }
+}
+async function resolvePolicyDecision(input) {
+  try {
+    return await Promise.resolve(input.permissionEvaluator.canUseTool(input.payload));
+  } catch {
+    return null;
+  }
+}
+async function runWithTimeout(promise, timeoutMs) {
+  if (timeoutMs <= 0) return promise;
+  let timeout;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timeout = setTimeout(() => reject(new Error("PERMISSION_CALLBACK_TIMEOUT")), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
+// src/v2/sessionBackend.types.ts
+var import_zod8 = require("zod");
+var BackendKindSchema = import_zod8.z.enum(["protocol", "runtime"]);
+var SessionBackendRouterConfigSchema = import_zod8.z.object({
+  defaultBackend: BackendKindSchema,
+  fallbackBackend: BackendKindSchema.optional(),
+  enableRuntimeBackend: import_zod8.z.boolean().default(false)
+});
+var DEFAULT_SESSION_BACKEND_ROUTER_CONFIG = {
+  defaultBackend: "protocol",
+  fallbackBackend: "protocol",
+  enableRuntimeBackend: false
+};
+var FallbackTriggerReasonSchema = import_zod8.z.enum([
+  "initialization_failure",
+  "execution_timeout",
+  "error_storm"
+]);
+var FALLBACK_TRIGGER_MATRIX = {
+  initialization_failure: true,
+  execution_timeout: true,
+  error_storm: true
+};
+var ProtocolErrorCodeSchema = import_zod8.z.enum([
+  "UNKNOWN_ERROR",
+  "NETWORK_ERROR",
+  "TIMEOUT",
+  "SESSION_NOT_FOUND",
+  "PERMISSION_DENIED",
+  "RATE_LIMITED",
+  "VALIDATION_ERROR",
+  "TOOL_EXECUTION_FAILED",
+  "STREAM_DISCONNECTED",
+  "SERVER_UNAVAILABLE"
+]);
+var S4_PROTOCOL_ERROR_TOP_CODES = [
+  "UNKNOWN_ERROR",
+  "NETWORK_ERROR",
+  "TIMEOUT",
+  "SESSION_NOT_FOUND",
+  "PERMISSION_DENIED",
+  "RATE_LIMITED",
+  "VALIDATION_ERROR",
+  "TOOL_EXECUTION_FAILED",
+  "STREAM_DISCONNECTED",
+  "SERVER_UNAVAILABLE"
+];
+var RuntimeEventErrorTypeSchema = import_zod8.z.enum([
+  "session.error",
+  "session.transport.error",
+  "session.permission.error",
+  "session.tool.error",
+  "session.validation.error",
+  "session.timeout.error"
+]);
+var ProtocolErrorMappingSchema = import_zod8.z.record(
+  ProtocolErrorCodeSchema,
+  RuntimeEventErrorTypeSchema
+);
+
+// src/v2/protocolSessionBackend.ts
+var PROTOCOL_ERROR_TO_RUNTIME_ERROR_TYPE = {
+  UNKNOWN_ERROR: "session.error",
+  NETWORK_ERROR: "session.transport.error",
+  TIMEOUT: "session.timeout.error",
+  SESSION_NOT_FOUND: "session.error",
+  PERMISSION_DENIED: "session.permission.error",
+  RATE_LIMITED: "session.transport.error",
+  VALIDATION_ERROR: "session.validation.error",
+  TOOL_EXECUTION_FAILED: "session.tool.error",
+  STREAM_DISCONNECTED: "session.transport.error",
+  SERVER_UNAVAILABLE: "session.transport.error"
+};
+function mapProtocolErrorCodeToRuntimeErrorType(code) {
+  return PROTOCOL_ERROR_TO_RUNTIME_ERROR_TYPE[code] ?? "session.error";
+}
+var ProtocolSessionStreamBindingManager = class {
+  bindings = /* @__PURE__ */ new Map();
+  register(protocolSessionId, sseChannelKey) {
+    const binding = {
+      protocolSessionId,
+      sseChannelKey,
+      createdAt: Date.now()
+    };
+    this.bindings.set(protocolSessionId, binding);
+    return binding;
+  }
+  get(protocolSessionId) {
+    return this.bindings.get(protocolSessionId);
+  }
+  unregister(protocolSessionId) {
+    this.bindings.delete(protocolSessionId);
+  }
+};
+function createProtocolSessionBackend(input) {
+  const pybClient = input?.pybClient ?? new PybClient();
+  const sseClient = input?.sseClient ?? createSSEClient();
+  const bindingManager = new ProtocolSessionStreamBindingManager();
+  return {
+    kind: "protocol",
+    async createSession(config) {
+      const created = await pybClient.session.create(
+        config.createSessionRequest ?? {}
+      );
+      const sessionId = created.sessionId;
+      bindingManager.register(sessionId, sessionId);
+      const legacyQueue = new AsyncEventQueue();
+      const runtimeQueue = new AsyncEventQueue();
+      const unsubscribe = sseClient.subscribeAll((event) => {
+        if (event.sessionId && event.sessionId !== sessionId) return;
+        const legacyEvent = {
+          type: event.type,
+          timestamp: event.timestamp ?? Date.now(),
+          sessionId,
+          data: event.data ?? {}
+        };
+        legacyQueue.push(legacyEvent);
+        runtimeQueue.push(
+          projectLegacyEventToRuntimeEvent({
+            type: legacyEvent.type,
+            sessionId,
+            timestamp: legacyEvent.timestamp,
+            requestId: extractRequestId(legacyEvent.data),
+            data: legacyEvent.data
+          })
+        );
+      });
+      sseClient.connect();
+      let closed = false;
+      return {
+        send(input2) {
+          if (closed) throw new Error("PROTOCOL_BACKEND_SESSION_CLOSED");
+          pybClient.session.prompt(sessionId, {
+            message: input2.message,
+            attachments: input2.attachments,
+            options: { stream: true }
+          }).catch((error) => {
+            const runtimeErrorEvent = toRuntimeErrorEvent(error, sessionId);
+            runtimeQueue.push(runtimeErrorEvent);
+            legacyQueue.push({
+              type: "error",
+              timestamp: Date.now(),
+              sessionId,
+              data: runtimeErrorEvent.data
+            });
+          });
+        },
+        async *stream() {
+          for await (const event of legacyQueue.stream()) {
+            yield event;
+          }
+        },
+        async *streamRuntimeEvents() {
+          for await (const event of runtimeQueue.stream()) {
+            yield event;
+          }
+        },
+        interrupt() {
+          if (closed) return;
+          pybClient.session.abort(sessionId).catch(() => {
+          });
+        },
+        async close() {
+          if (closed) return;
+          closed = true;
+          unsubscribe();
+          sseClient.disconnect();
+          bindingManager.unregister(sessionId);
+          legacyQueue.close();
+          runtimeQueue.close();
+        },
+        status: "pending"
+      };
+    }
+  };
+}
+var AsyncEventQueue = class {
+  values = [];
+  waits = [];
+  ended = false;
+  push(value) {
+    if (this.ended) return;
+    const wait = this.waits.shift();
+    if (wait) {
+      wait({ value, done: false });
+      return;
+    }
+    this.values.push(value);
+  }
+  close() {
+    this.ended = true;
+    while (this.waits.length > 0) {
+      const wait = this.waits.shift();
+      wait?.({ value: void 0, done: true });
+    }
+  }
+  async *stream() {
+    while (true) {
+      if (this.values.length > 0) {
+        yield this.values.shift();
+        continue;
+      }
+      if (this.ended) return;
+      const next = await new Promise((resolve) => {
+        this.waits.push(resolve);
+      });
+      if (next.done) return;
+      yield next.value;
+    }
+  }
+};
+function extractRequestId(data) {
+  return typeof data.requestId === "string" ? data.requestId : void 0;
+}
+function toRuntimeErrorEvent(error, sessionId) {
+  const code = readErrorCode(error);
+  const mappedType = mapProtocolErrorCodeToRuntimeErrorType(code);
+  return projectLegacyEventToRuntimeEvent({
+    type: "error",
+    sessionId,
+    timestamp: Date.now(),
+    data: {
+      code,
+      runtimeErrorType: mappedType,
+      message: readErrorMessage(error),
+      recoverable: mappedType !== "session.validation.error"
+    }
+  });
+}
+function readErrorCode(error) {
+  if (isRecord2(error) && typeof error.code === "string") {
+    const matched = error.code;
+    if (matched in PROTOCOL_ERROR_TO_RUNTIME_ERROR_TYPE) return matched;
+  }
+  return "UNKNOWN_ERROR";
+}
+function readErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (isRecord2(error) && typeof error.message === "string") return error.message;
+  return "protocol backend session error";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/v2/runtimeSessionBackend.ts
+function createRuntimeSessionBackend(input) {
+  const createSessionImpl = input?.createRuntimeSession ?? createRuntimeSession;
+  return {
+    kind: "runtime",
+    async createSession(config) {
+      const sessionId = resolveSessionId(config);
+      const runtimeSessionConfig = resolveRuntimeSessionConfig(config);
+      let runtimeSession;
+      try {
+        runtimeSession = createSessionImpl({
+          sessionId,
+          ...runtimeSessionConfig
+        });
+      } catch (error) {
+        throw toRuntimeBackendInitializationError({
+          event: mapRuntimeBackendErrorToRuntimeEvent({
+            error,
+            sessionId,
+            phase: "initialization"
+          })
+        });
+      }
+      let closed = false;
+      return {
+        send(input2) {
+          if (closed) throw new Error("RUNTIME_BACKEND_SESSION_CLOSED");
+          runtimeSession.send(input2);
+        },
+        async *stream() {
+          try {
+            for await (const event of runtimeSession.stream()) {
+              yield {
+                type: event.type,
+                timestamp: Date.now(),
+                sessionId,
+                data: withBackendSource(event.data)
+              };
+            }
+          } catch (error) {
+            const runtimeError = mapRuntimeBackendErrorToRuntimeEvent({
+              error,
+              sessionId,
+              phase: "execution"
+            });
+            yield {
+              type: "error",
+              timestamp: runtimeError.timestamp,
+              sessionId,
+              data: runtimeError.data
+            };
+          }
+        },
+        async *streamRuntimeEvents() {
+          try {
+            for await (const event of runtimeSession.streamRuntimeEvents()) {
+              yield withRuntimeBackendSource(event);
+            }
+          } catch (error) {
+            yield mapRuntimeBackendErrorToRuntimeEvent({
+              error,
+              sessionId,
+              phase: "execution"
+            });
+          }
+        },
+        interrupt() {
+          if (closed) return;
+          runtimeSession.interrupt();
+        },
+        async close() {
+          if (closed) return;
+          closed = true;
+          await runtimeSession.close();
+        },
+        status: runtimeSession.status
+      };
+    }
+  };
+}
+function mapRuntimeBackendErrorToRuntimeEvent(input) {
+  return {
+    domain: "session",
+    type: "session.error",
+    sessionId: input.sessionId,
+    timestamp: Date.now(),
+    data: {
+      backendSource: "runtime",
+      phase: input.phase,
+      message: readErrorMessage2(input.error),
+      recoverable: input.phase !== "initialization"
+    }
+  };
+}
+function withRuntimeBackendSource(event) {
+  const eventRecord = event;
+  return {
+    ...event,
+    data: withBackendSource(eventRecord.data)
+  };
+}
+function withBackendSource(data) {
+  if (!isRecord3(data)) return { backendSource: "runtime" };
+  return { ...data, backendSource: "runtime" };
+}
+function resolveSessionId(config) {
+  if (typeof config.sessionId === "string" && config.sessionId.length > 0) {
+    return config.sessionId;
+  }
+  return `runtime-${Date.now()}`;
+}
+function resolveRuntimeSessionConfig(config) {
+  const candidate = config.runtimeSessionConfig;
+  if (!isRecord3(candidate)) return {};
+  return candidate;
+}
+function toRuntimeBackendInitializationError(input) {
+  const error = new Error("RUNTIME_BACKEND_SESSION_INIT_FAILED");
+  error.runtimeEvent = input.event;
+  return error;
+}
+function readErrorMessage2(error) {
+  if (error instanceof Error) return error.message;
+  if (isRecord3(error) && typeof error.message === "string") return error.message;
+  return "runtime backend session error";
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/v2/sessionBackendConfig.ts
+var SESSION_BACKEND_CONFIG_CONTRACT_VERSION = "s5-a0";
+var SESSION_BACKEND_ENV_KEY = "PYB_DEFAULT_BACKEND";
+var SESSION_BACKEND_OBSERVABILITY_SPEC = {
+  backendSource: ["default", "env_config", "file_config", "user_explicit", "fallback"],
+  fallbackReason: ["initialization_failure", "execution_timeout", "error_storm"],
+  routeSource: ["default", "env_config", "user_explicit"]
+};
+var S5_A0_EQUIVALENCE_SAMPLE_SET = [
+  {
+    id: "EQU-001",
+    scenario: "\u666E\u901A\u5BF9\u8BDD\u8F6E\u6B21",
+    assertions: ["\u6D88\u606F\u5185\u5BB9\u4E00\u81F4", "\u4E8B\u4EF6\u5E8F\u5217\u4E00\u81F4", "\u72B6\u6001\u53D8\u5316\u4E00\u81F4"]
+  },
+  {
+    id: "EQU-002",
+    scenario: "\u5DE5\u5177\u8C03\u7528\u8F6E\u6B21",
+    assertions: ["\u5DE5\u5177\u6267\u884C\u7ED3\u679C\u4E00\u81F4", "\u4E8B\u4EF6\u5E8F\u5217\u4E00\u81F4"]
+  },
+  {
+    id: "EQU-003",
+    scenario: "\u6743\u9650\u62D2\u7EDD\u8F6E\u6B21",
+    assertions: ["\u62D2\u7EDD\u539F\u56E0\u4E00\u81F4", "\u4E8B\u4EF6\u5E8F\u5217\u4E00\u81F4"]
+  },
+  {
+    id: "EQU-004",
+    scenario: "\u4E2D\u65AD\u4E0E\u6062\u590D\u8F6E\u6B21",
+    assertions: ["\u4E2D\u65AD\u884C\u4E3A\u4E00\u81F4", "\u6062\u590D\u540E\u72B6\u6001\u4E00\u81F4"]
+  },
+  {
+    id: "EQU-005",
+    scenario: "\u9519\u8BEF\u5904\u7406\u8F6E\u6B21",
+    assertions: ["\u9519\u8BEF\u4E8B\u4EF6\u4E00\u81F4", "\u72B6\u6001\u53D8\u5316\u4E00\u81F4"]
+  },
+  {
+    id: "EQU-006",
+    scenario: "\u591A\u8F6E\u5BF9\u8BDD",
+    assertions: ["\u6D88\u606F\u5386\u53F2\u4E00\u81F4", "\u4E0A\u4E0B\u6587\u4FDD\u6301\u4E00\u81F4"]
+  }
+];
+function emitBackendConfigWarning(value, emitWarning = console.warn) {
+  emitWarning(
+    `[sdk-session-backend-config] Invalid ${SESSION_BACKEND_ENV_KEY} value "${String(
+      value
+    )}", fallback to "runtime".`
+  );
+}
+function resolveDefaultBackend(config, input) {
+  const value = config?.PYB_DEFAULT_BACKEND;
+  if (value === "protocol" || value === "runtime") return value;
+  if (value !== void 0) {
+    emitBackendConfigWarning(value, input?.emitWarning);
+  }
+  return "runtime";
+}
+function resolveDefaultBackendFromEnv(input) {
+  const env = input?.env ?? process.env;
+  const envValue = env[SESSION_BACKEND_ENV_KEY];
+  const defaultBackend = resolveDefaultBackend(
+    envValue === void 0 ? void 0 : { PYB_DEFAULT_BACKEND: envValue },
+    { emitWarning: input?.emitWarning }
+  );
+  return {
+    defaultBackend,
+    routeSource: envValue === "protocol" || envValue === "runtime" ? "env_config" : "default"
+  };
+}
+
+// src/v2/sessionBackendRouter.ts
+function createSessionBackendRouter(input) {
+  const resolvedFromEnv = resolveDefaultBackendFromEnv({
+    env: input.env,
+    emitWarning: input.emitWarning
+  });
+  const routerConfig = SessionBackendRouterConfigSchema.parse({
+    ...DEFAULT_SESSION_BACKEND_ROUTER_CONFIG,
+    defaultBackend: resolvedFromEnv.defaultBackend,
+    enableRuntimeBackend: true,
+    ...input.routerConfig ?? {}
+  });
+  return {
+    kind: resolveRouterBackendKind({
+      preferredBackend: void 0,
+      config: routerConfig
+    }),
+    async createSession(config) {
+      const preferred = readPreferredBackend(config);
+      const routeSource = resolveRouteSource({
+        preferredBackend: preferred,
+        envRouteSource: resolvedFromEnv.routeSource
+      });
+      const primaryKind = resolveRouterBackendKind({
+        preferredBackend: preferred,
+        config: routerConfig
+      });
+      const fallbackKind = primaryKind === routerConfig.fallbackBackend ? void 0 : routerConfig.fallbackBackend;
+      let currentBackendKind = primaryKind;
+      let fallbackReason;
+      let pendingFallbackReason;
+      let continuousSendErrors = 0;
+      let currentSession;
+      try {
+        currentSession = await resolveBackend(input, primaryKind).createSession(config);
+      } catch (error) {
+        if (!fallbackKind || !shouldTriggerFallback("initialization_failure")) throw error;
+        currentSession = await resolveBackend(input, fallbackKind).createSession(config);
+        currentBackendKind = fallbackKind;
+        fallbackReason = "initialization_failure";
+      }
+      async function activateFallback(reason) {
+        if (!fallbackKind || !shouldTriggerFallback(reason)) {
+          throw new Error(`FALLBACK_NOT_AVAILABLE:${reason}`);
+        }
+        currentSession = await resolveBackend(input, fallbackKind).createSession(config);
+        currentBackendKind = fallbackKind;
+        fallbackReason = reason;
+        pendingFallbackReason = void 0;
+        continuousSendErrors = 0;
+      }
+      async function ensureFallbackActivatedIfNeeded() {
+        if (!pendingFallbackReason) return;
+        await activateFallback(pendingFallbackReason);
+      }
+      function buildRuntimeEvent(event) {
+        return injectRoutingMetaToRuntimeEvent(event, {
+          backendSource: currentBackendKind,
+          routeSource,
+          fallbackReason
+        });
+      }
+      function buildLegacyEvent(event) {
+        return injectRoutingMetaToLegacyEvent(event, {
+          backendSource: currentBackendKind,
+          routeSource,
+          fallbackReason
+        });
+      }
+      return {
+        send(inputValue) {
+          if (pendingFallbackReason) return;
+          try {
+            currentSession.send(inputValue);
+            continuousSendErrors = 0;
+            return;
+          } catch (error) {
+            if (isTimeoutError(error)) {
+              pendingFallbackReason = "execution_timeout";
+              return;
+            }
+            continuousSendErrors += 1;
+            if (continuousSendErrors >= 3) {
+              pendingFallbackReason = "error_storm";
+              return;
+            }
+            throw error;
+          }
+        },
+        async *stream() {
+          await ensureFallbackActivatedIfNeeded();
+          for await (const event of currentSession.stream()) {
+            yield buildLegacyEvent(event);
+          }
+        },
+        async *streamRuntimeEvents() {
+          await ensureFallbackActivatedIfNeeded();
+          if (currentSession.streamRuntimeEvents) {
+            for await (const event of currentSession.streamRuntimeEvents()) {
+              yield buildRuntimeEvent(event);
+            }
+            return;
+          }
+          for await (const event of currentSession.stream()) {
+            yield buildRuntimeEvent(projectLegacyEventToRuntimeEvent(toProjectableLegacyEvent(event)));
+          }
+        },
+        interrupt() {
+          currentSession.interrupt();
+        },
+        async close() {
+          await currentSession.close();
+        },
+        get status() {
+          return currentSession.status;
+        }
+      };
+    }
+  };
+}
+function shouldTriggerFallback(reason) {
+  return FALLBACK_TRIGGER_MATRIX[reason] === true;
+}
+function resolveRouterBackendKind(input) {
+  const preferred = input.preferredBackend ?? input.config.defaultBackend;
+  if (preferred === "runtime" && !input.config.enableRuntimeBackend) return "protocol";
+  return preferred;
+}
+function resolveBackend(input, kind) {
+  if (kind === "protocol") return input.protocolBackend;
+  if (!input.runtimeBackend) throw new Error("RUNTIME_BACKEND_NOT_AVAILABLE");
+  return input.runtimeBackend;
+}
+function readPreferredBackend(config) {
+  if (config.preferredBackend === "protocol") return "protocol";
+  if (config.preferredBackend === "runtime") return "runtime";
+  return void 0;
+}
+function resolveRouteSource(input) {
+  if (input.preferredBackend) return "user_explicit";
+  if (input.envRouteSource === "env_config") return "env_config";
+  return "default";
+}
+function injectRoutingMetaToLegacyEvent(event, input) {
+  const data = isRecord4(event.data) ? event.data : {};
+  return {
+    ...event,
+    data: {
+      ...data,
+      backendSource: input.backendSource,
+      routeSource: input.routeSource,
+      ...input.fallbackReason ? { fallbackReason: input.fallbackReason } : {}
+    }
+  };
+}
+function injectRoutingMetaToRuntimeEvent(event, input) {
+  const data = isRecord4(event.data) ? event.data : {};
+  return {
+    ...event,
+    data: {
+      ...data,
+      backendSource: input.backendSource,
+      routeSource: input.routeSource,
+      ...input.fallbackReason ? { fallbackReason: input.fallbackReason } : {}
+    }
+  };
+}
+function isTimeoutError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.toLowerCase().includes("timeout");
+}
+function toProjectableLegacyEvent(input) {
+  const data = isRecord4(input.data) ? input.data : {};
+  const type = typeof input.type === "string" ? input.type : "unknown";
+  const sessionId = typeof input.sessionId === "string" ? input.sessionId : typeof data.sessionId === "string" ? data.sessionId : "unknown-session";
+  const requestId = typeof input.requestId === "string" ? input.requestId : typeof data.requestId === "string" ? data.requestId : void 0;
+  const timestamp = typeof input.timestamp === "number" ? input.timestamp : void 0;
+  return {
+    type,
+    sessionId,
+    requestId,
+    timestamp,
+    data
+  };
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/index.ts
+var SDK_VERSION = "0.1.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BackendKindSchema,
+  ContentBlockSchema,
+  DEFAULT_SESSION_BACKEND_ROUTER_CONFIG,
+  DualTrackMetricsSchema,
+  DualTrackRawStatsSchema,
+  DualTrackThresholdsSchema,
+  ErrorEventSchema,
+  ErrorStreamEventSchema,
+  FALLBACK_TRIGGER_MATRIX,
+  FallbackTriggerReasonSchema,
+  MessageCompletedEventSchema,
+  MessageCreatedEventSchema,
+  MessageSchema,
+  MessageUpdatedEventSchema,
+  PROTOCOL_ERROR_TO_RUNTIME_ERROR_TYPE,
+  PermissionRequestedEventSchema,
+  PermissionRespondedEventSchema,
+  PermissionTimeoutEventSchema,
+  ProtocolErrorCodeSchema,
+  ProtocolErrorMappingSchema,
+  ProtocolSessionStreamBindingManager,
+  PybClient,
+  PybSSEEventSchema,
+  RequestCompletedEventSchema,
+  RequestStartedEventSchema,
+  RuntimeEventDomainSchema,
+  RuntimeEventErrorTypeSchema,
+  RuntimeEventSchema,
+  RuntimeSessionEventSchema,
+  RuntimeSessionInputSchema,
+  RuntimeSessionStatusSchema,
+  S4_PROTOCOL_ERROR_TOP_CODES,
+  S5_A0_EQUIVALENCE_SAMPLE_SET,
+  SDK_VERSION,
+  SESSION_BACKEND_CONFIG_CONTRACT_VERSION,
+  SESSION_BACKEND_ENV_KEY,
+  SESSION_BACKEND_OBSERVABILITY_SPEC,
+  SSEClient,
+  SSEDedupEventSchema,
+  SSEReplayEventSchema,
+  SSEReplayGapEventSchema,
+  ServerConnectedEventSchema,
+  ServerHeartbeatEventSchema,
+  ServerStatusEventSchema,
+  SessionBackendRouterConfigSchema,
+  SessionCreatedEventSchema,
+  SessionDeletedEventSchema,
+  SessionUpdatedEventSchema,
+  ToolCompletedEventSchema,
+  ToolErrorEventSchema,
+  ToolProgressEventSchema,
+  ToolStartedEventSchema,
+  V2MessageSchema,
+  V2RequestStatusSchema,
+  V2SessionSchema,
+  V2SessionStatusSchema,
+  V2ToolUseContextSchema,
+  buildDefaultDualTrackThresholds,
+  buildV2ToolUseContextFromPromptRequest,
+  canTransitionV2SessionStatus,
+  createDefaultToolPermissionContextForSdk,
+  createProtocolSessionBackend,
+  createRuntimePermissionContextForSession,
+  createRuntimeSession,
+  createRuntimeSessionBackend,
+  createSSEClient,
+  createSessionBackendRouter,
+  emitBackendConfigWarning,
+  evaluateDualTrackMetrics,
+  evaluateV1DeprecationReadiness,
+  getRuntimeEventMappingRules,
+  isToolAutoExecutableInContext,
+  mapProtocolErrorCodeToRuntimeErrorType,
+  mapRuntimeBackendErrorToRuntimeEvent,
+  mapRuntimeMessageToV2,
+  mapRuntimeSessionStatusToV2,
+  mapV1MessageToV2,
+  mapV1SessionStatusToV2,
+  projectLegacyEventToRuntimeEvent,
+  projectRuntimeEventToLegacyEvent,
+  resolveDefaultBackend,
+  resolveDefaultBackendFromEnv,
+  resolvePermissionDecision,
+  resolvePermissionModeForSdk,
+  resolveRouterBackendKind,
+  shouldTriggerFallback,
+  validateV2Message,
+  validateV2Session,
+  validateV2ToolUseContext
+});