@github/copilot-sdk 0.1.33-preview.1 → 0.1.33-preview.3

package/dist/client.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import { Socket } from "node:net";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -12,6 +13,7 @@ import {
 import { createServerRpc } from "./generated/rpc.js";
 import { getSdkProtocolVersion } from "./sdkProtocolVersion.js";
 import { CopilotSession, NO_RESULT_PERMISSION_V2_ERROR } from "./session.js";
+import { getTraceContext } from "./telemetry.js";
 const MIN_PROTOCOL_VERSION = 2;
 function isZodSchema(value) {
   return value != null && typeof value === "object" && "toJSONSchema" in value && typeof value.toJSONSchema === "function";
@@ -30,9 +32,22 @@ function getNodeExecPath() {
   return process.execPath;
 }
 function getBundledCliPath() {
-  const sdkUrl = import.meta.resolve("@github/copilot/sdk");
-  const sdkPath = fileURLToPath(sdkUrl);
-  return join(dirname(dirname(sdkPath)), "index.js");
+  if (typeof import.meta.resolve === "function") {
+    const sdkUrl = import.meta.resolve("@github/copilot/sdk");
+    const sdkPath = fileURLToPath(sdkUrl);
+    return join(dirname(dirname(sdkPath)), "index.js");
+  }
+  const req = createRequire(__filename);
+  const searchPaths = req.resolve.paths("@github/copilot") ?? [];
+  for (const base of searchPaths) {
+    const candidate = join(base, "@github", "copilot", "index.js");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Could not find @github/copilot package. Searched ${searchPaths.length} paths. Ensure it is installed, or pass cliPath/cliUrl to CopilotClient.`
+  );
 }
 class CopilotClient {
   cliProcess = null;
@@ -48,6 +63,7 @@ class CopilotClient {
   isExternalServer = false;
   forceStopping = false;
   onListModels;
+  onGetTraceContext;
   modelsCache = null;
   modelsCacheLock = Promise.resolve();
   sessionLifecycleHandlers = /* @__PURE__ */ new Set();
@@ -114,6 +130,7 @@ class CopilotClient {
       this.isExternalServer = true;
     }
     this.onListModels = options.onListModels;
+    this.onGetTraceContext = options.onGetTraceContext;
     this.options = {
       cliPath: options.cliUrl ? void 0 : options.cliPath || getBundledCliPath(),
       cliArgs: options.cliArgs ?? [],
@@ -129,7 +146,8 @@ class CopilotClient {
       env: options.env ?? process.env,
       githubToken: options.githubToken,
       // Default useLoggedInUser to false when githubToken is provided, otherwise true
-      useLoggedInUser: options.useLoggedInUser ?? (options.githubToken ? false : true)
+      useLoggedInUser: options.useLoggedInUser ?? (options.githubToken ? false : true),
+      telemetry: options.telemetry
     };
   }
   /**
@@ -382,7 +400,12 @@ class CopilotClient {
       }
     }
     const sessionId = config.sessionId ?? randomUUID();
-    const session = new CopilotSession(sessionId, this.connection);
+    const session = new CopilotSession(
+      sessionId,
+      this.connection,
+      void 0,
+      this.onGetTraceContext
+    );
     session.registerTools(config.tools);
     session.registerPermissionHandler(config.onPermissionRequest);
     if (config.onUserInputRequest) {
@@ -397,6 +420,7 @@ class CopilotClient {
     this.sessions.set(sessionId, session);
     try {
       const response = await this.connection.sendRequest("session.create", {
+        ...await getTraceContext(this.onGetTraceContext),
         model: config.model,
         sessionId,
         clientName: config.clientName,
@@ -471,7 +495,12 @@ class CopilotClient {
         throw new Error("Client not connected. Call start() first.");
       }
     }
-    const session = new CopilotSession(sessionId, this.connection);
+    const session = new CopilotSession(
+      sessionId,
+      this.connection,
+      void 0,
+      this.onGetTraceContext
+    );
     session.registerTools(config.tools);
     session.registerPermissionHandler(config.onPermissionRequest);
     if (config.onUserInputRequest) {
@@ -486,6 +515,7 @@ class CopilotClient {
     this.sessions.set(sessionId, session);
     try {
       const response = await this.connection.sendRequest("session.resume", {
+        ...await getTraceContext(this.onGetTraceContext),
         sessionId,
         clientName: config.clientName,
         model: config.model,
@@ -829,6 +859,22 @@ class CopilotClient {
           "Path to Copilot CLI is required. Please provide it via the cliPath option, or use cliUrl to rely on a remote CLI."
         );
       }
+      if (this.options.telemetry) {
+        const t = this.options.telemetry;
+        envWithoutNodeDebug.COPILOT_OTEL_ENABLED = "true";
+        if (t.otlpEndpoint !== void 0)
+          envWithoutNodeDebug.OTEL_EXPORTER_OTLP_ENDPOINT = t.otlpEndpoint;
+        if (t.filePath !== void 0)
+          envWithoutNodeDebug.COPILOT_OTEL_FILE_EXPORTER_PATH = t.filePath;
+        if (t.exporterType !== void 0)
+          envWithoutNodeDebug.COPILOT_OTEL_EXPORTER_TYPE = t.exporterType;
+        if (t.sourceName !== void 0)
+          envWithoutNodeDebug.COPILOT_OTEL_SOURCE_NAME = t.sourceName;
+        if (t.captureContent !== void 0)
+          envWithoutNodeDebug.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT = String(
+            t.captureContent
+          );
+      }
       if (!existsSync(this.options.cliPath)) {
         throw new Error(
           `Copilot CLI not found at ${this.options.cliPath}. Ensure @github/copilot is installed.`
@@ -1123,11 +1169,15 @@ stderr: ${stderrOutput}`
       };
     }
     try {
+      const traceparent = params.traceparent;
+      const tracestate = params.tracestate;
       const invocation = {
         sessionId: params.sessionId,
         toolCallId: params.toolCallId,
         toolName: params.toolName,
-        arguments: params.arguments
+        arguments: params.arguments,
+        traceparent,
+        tracestate
       };
       const result = await handler(params.arguments, invocation);
       return { result: this.normalizeToolResultV2(result) };

package/dist/generated/rpc.d.ts

@@ -315,12 +315,14 @@ export interface SessionWorkspaceCreateFileParams {
      */
     content: string;
 }
+/** @experimental */
 export interface SessionFleetStartResult {
     /**
      * Whether fleet mode was successfully activated
      */
     started: boolean;
 }
+/** @experimental */
 export interface SessionFleetStartParams {
     /**
      * Target session identifier
@@ -331,6 +333,7 @@ export interface SessionFleetStartParams {
      */
     prompt?: string;
 }
+/** @experimental */
 export interface SessionAgentListResult {
     /**
      * Available custom agents
@@ -350,12 +353,14 @@ export interface SessionAgentListResult {
         description: string;
     }[];
 }
+/** @experimental */
 export interface SessionAgentListParams {
     /**
      * Target session identifier
      */
     sessionId: string;
 }
+/** @experimental */
 export interface SessionAgentGetCurrentResult {
     /**
      * Currently selected custom agent, or null if using the default agent
@@ -375,12 +380,14 @@ export interface SessionAgentGetCurrentResult {
         description: string;
     } | null;
 }
+/** @experimental */
 export interface SessionAgentGetCurrentParams {
     /**
      * Target session identifier
      */
     sessionId: string;
 }
+/** @experimental */
 export interface SessionAgentSelectResult {
     /**
      * The newly selected custom agent
@@ -400,6 +407,7 @@ export interface SessionAgentSelectResult {
         description: string;
     };
 }
+/** @experimental */
 export interface SessionAgentSelectParams {
     /**
      * Target session identifier
@@ -410,14 +418,17 @@ export interface SessionAgentSelectParams {
      */
     name: string;
 }
+/** @experimental */
 export interface SessionAgentDeselectResult {
 }
+/** @experimental */
 export interface SessionAgentDeselectParams {
     /**
      * Target session identifier
      */
     sessionId: string;
 }
+/** @experimental */
 export interface SessionCompactionCompactResult {
     /**
      * Whether compaction completed successfully
@@ -432,6 +443,7 @@ export interface SessionCompactionCompactResult {
      */
     messagesRemoved: number;
 }
+/** @experimental */
 export interface SessionCompactionCompactParams {
     /**
      * Target session identifier
@@ -589,15 +601,18 @@ export declare function createSessionRpc(connection: MessageConnection, sessionI
         readFile: (params: Omit<SessionWorkspaceReadFileParams, "sessionId">) => Promise<SessionWorkspaceReadFileResult>;
         createFile: (params: Omit<SessionWorkspaceCreateFileParams, "sessionId">) => Promise<SessionWorkspaceCreateFileResult>;
     };
+    /** @experimental */
     fleet: {
         start: (params: Omit<SessionFleetStartParams, "sessionId">) => Promise<SessionFleetStartResult>;
     };
+    /** @experimental */
     agent: {
         list: () => Promise<SessionAgentListResult>;
         getCurrent: () => Promise<SessionAgentGetCurrentResult>;
         select: (params: Omit<SessionAgentSelectParams, "sessionId">) => Promise<SessionAgentSelectResult>;
         deselect: () => Promise<SessionAgentDeselectResult>;
     };
+    /** @experimental */
     compaction: {
         compact: () => Promise<SessionCompactionCompactResult>;
     };

package/dist/generated/rpc.js

@@ -32,15 +32,18 @@ function createSessionRpc(connection, sessionId) {
       readFile: async (params) => connection.sendRequest("session.workspace.readFile", { sessionId, ...params }),
       createFile: async (params) => connection.sendRequest("session.workspace.createFile", { sessionId, ...params })
     },
+    /** @experimental */
     fleet: {
       start: async (params) => connection.sendRequest("session.fleet.start", { sessionId, ...params })
     },
+    /** @experimental */
     agent: {
       list: async () => connection.sendRequest("session.agent.list", { sessionId }),
       getCurrent: async () => connection.sendRequest("session.agent.getCurrent", { sessionId }),
       select: async (params) => connection.sendRequest("session.agent.select", { sessionId, ...params }),
       deselect: async () => connection.sendRequest("session.agent.deselect", { sessionId })
     },
+    /** @experimental */
     compaction: {
       compact: async () => connection.sendRequest("session.compaction.compact", { sessionId })
     },

package/dist/index.d.ts

@@ -6,4 +6,4 @@
 export { CopilotClient } from "./client.js";
 export { CopilotSession, type AssistantMessageEvent } from "./session.js";
 export { defineTool, approveAll } from "./types.js";
-export type { ConnectionState, CopilotClientOptions, CustomAgentConfig, ForegroundSessionInfo, GetAuthStatusResponse, GetStatusResponse, InfiniteSessionConfig, MCPLocalServerConfig, MCPRemoteServerConfig, MCPServerConfig, MessageOptions, ModelBilling, ModelCapabilities, ModelInfo, ModelPolicy, PermissionHandler, PermissionRequest, PermissionRequestResult, ResumeSessionConfig, SessionConfig, SessionEvent, SessionEventHandler, SessionEventPayload, SessionEventType, SessionLifecycleEvent, SessionLifecycleEventType, SessionLifecycleHandler, SessionContext, SessionListFilter, SessionMetadata, SystemMessageAppendConfig, SystemMessageConfig, SystemMessageReplaceConfig, Tool, ToolHandler, ToolInvocation, ToolResultObject, TypedSessionEventHandler, TypedSessionLifecycleHandler, ZodSchema, } from "./types.js";
+export type { ConnectionState, CopilotClientOptions, CustomAgentConfig, ForegroundSessionInfo, GetAuthStatusResponse, GetStatusResponse, InfiniteSessionConfig, MCPLocalServerConfig, MCPRemoteServerConfig, MCPServerConfig, MessageOptions, ModelBilling, ModelCapabilities, ModelInfo, ModelPolicy, PermissionHandler, PermissionRequest, PermissionRequestResult, ResumeSessionConfig, SessionConfig, SessionEvent, SessionEventHandler, SessionEventPayload, SessionEventType, SessionLifecycleEvent, SessionLifecycleEventType, SessionLifecycleHandler, SessionContext, SessionListFilter, SessionMetadata, SystemMessageAppendConfig, SystemMessageConfig, SystemMessageReplaceConfig, TelemetryConfig, TraceContext, TraceContextProvider, Tool, ToolHandler, ToolInvocation, ToolResultObject, TypedSessionEventHandler, TypedSessionLifecycleHandler, ZodSchema, } from "./types.js";

package/dist/session.d.ts

@@ -4,7 +4,7 @@
  */
 import type { MessageConnection } from "vscode-jsonrpc/node.js";
 import { createSessionRpc } from "./generated/rpc.js";
-import type { MessageOptions, PermissionHandler, PermissionRequestResult, SessionEvent, SessionEventHandler, SessionEventType, SessionHooks, Tool, ToolHandler, TypedSessionEventHandler, UserInputHandler, UserInputResponse } from "./types.js";
+import type { MessageOptions, PermissionHandler, PermissionRequestResult, ReasoningEffort, SessionEvent, SessionEventHandler, SessionEventType, SessionHooks, Tool, ToolHandler, TraceContextProvider, TypedSessionEventHandler, UserInputHandler, UserInputResponse } from "./types.js";
 export declare const NO_RESULT_PERMISSION_V2_ERROR = "Permission handlers cannot return 'no-result' when connected to a protocol v2 server.";
 /** Assistant message event - the final response from the assistant. */
 export type AssistantMessageEvent = Extract<SessionEvent, {
@@ -46,15 +46,17 @@ export declare class CopilotSession {
     private userInputHandler?;
     private hooks?;
     private _rpc;
+    private traceContextProvider?;
     /**
      * Creates a new CopilotSession instance.
      *
      * @param sessionId - The unique identifier for this session
      * @param connection - The JSON-RPC message connection to the Copilot CLI
      * @param workspacePath - Path to the session workspace directory (when infinite sessions enabled)
+     * @param traceContextProvider - Optional callback to get W3C Trace Context for outbound RPCs
      * @internal This constructor is internal. Use {@link CopilotClient.createSession} to create sessions.
      */
-    constructor(sessionId: string, connection: MessageConnection, _workspacePath?: string | undefined);
+    constructor(sessionId: string, connection: MessageConnection, _workspacePath?: string | undefined, traceContextProvider?: TraceContextProvider);
     /**
      * Typed session-scoped RPC methods.
      */
@@ -333,13 +335,17 @@ export declare class CopilotSession {
      * The new model takes effect for the next message. Conversation history is preserved.
      *
      * @param model - Model ID to switch to
+     * @param options - Optional settings for the new model
      *
      * @example
      * ```typescript
      * await session.setModel("gpt-4.1");
+     * await session.setModel("claude-sonnet-4.6", { reasoningEffort: "high" });
      * ```
      */
-    setModel(model: string): Promise<void>;
+    setModel(model: string, options?: {
+        reasoningEffort?: ReasoningEffort;
+    }): Promise<void>;
     /**
      * Log a message to the session timeline.
      * The message appears in the session event stream and is visible to SDK consumers

package/dist/session.js

@@ -1,5 +1,6 @@
 import { ConnectionError, ResponseError } from "vscode-jsonrpc/node.js";
 import { createSessionRpc } from "./generated/rpc.js";
+import { getTraceContext } from "./telemetry.js";
 const NO_RESULT_PERMISSION_V2_ERROR = "Permission handlers cannot return 'no-result' when connected to a protocol v2 server.";
 class CopilotSession {
   /**
@@ -8,12 +9,14 @@ class CopilotSession {
    * @param sessionId - The unique identifier for this session
    * @param connection - The JSON-RPC message connection to the Copilot CLI
    * @param workspacePath - Path to the session workspace directory (when infinite sessions enabled)
+   * @param traceContextProvider - Optional callback to get W3C Trace Context for outbound RPCs
    * @internal This constructor is internal. Use {@link CopilotClient.createSession} to create sessions.
    */
-  constructor(sessionId, connection, _workspacePath) {
+  constructor(sessionId, connection, _workspacePath, traceContextProvider) {
     this.sessionId = sessionId;
     this.connection = connection;
     this._workspacePath = _workspacePath;
+    this.traceContextProvider = traceContextProvider;
   }
   eventHandlers = /* @__PURE__ */ new Set();
   typedEventHandlers = /* @__PURE__ */ new Map();
@@ -22,6 +25,7 @@ class CopilotSession {
   userInputHandler;
   hooks;
   _rpc = null;
+  traceContextProvider;
   /**
    * Typed session-scoped RPC methods.
    */
@@ -59,6 +63,7 @@ class CopilotSession {
    */
   async send(options) {
     const response = await this.connection.sendRequest("session.send", {
+      ...await getTraceContext(this.traceContextProvider),
       sessionId: this.sessionId,
       prompt: options.prompt,
       attachments: options.attachments,
@@ -188,9 +193,19 @@ class CopilotSession {
       const { requestId, toolName } = event.data;
       const args = event.data.arguments;
       const toolCallId = event.data.toolCallId;
+      const traceparent = event.data.traceparent;
+      const tracestate = event.data.tracestate;
       const handler = this.toolHandlers.get(toolName);
       if (handler) {
-        void this._executeToolAndRespond(requestId, toolName, toolCallId, args, handler);
+        void this._executeToolAndRespond(
+          requestId,
+          toolName,
+          toolCallId,
+          args,
+          handler,
+          traceparent,
+          tracestate
+        );
       }
     } else if (event.type === "permission.requested") {
       const { requestId, permissionRequest } = event.data;
@@ -203,13 +218,15 @@ class CopilotSession {
    * Executes a tool handler and sends the result back via RPC.
    * @internal
    */
-  async _executeToolAndRespond(requestId, toolName, toolCallId, args, handler) {
+  async _executeToolAndRespond(requestId, toolName, toolCallId, args, handler, traceparent, tracestate) {
     try {
       const rawResult = await handler(args, {
         sessionId: this.sessionId,
         toolCallId,
         toolName,
-        arguments: args
+        arguments: args,
+        traceparent,
+        tracestate
       });
       let result;
       if (rawResult == null) {
@@ -502,14 +519,16 @@ class CopilotSession {
    * The new model takes effect for the next message. Conversation history is preserved.
    *
    * @param model - Model ID to switch to
+   * @param options - Optional settings for the new model
    *
    * @example
    * ```typescript
    * await session.setModel("gpt-4.1");
+   * await session.setModel("claude-sonnet-4.6", { reasoningEffort: "high" });
    * ```
    */
-  async setModel(model) {
-    await this.rpc.model.switchTo({ modelId: model });
+  async setModel(model, options) {
+    await this.rpc.model.switchTo({ modelId: model, ...options });
   }
   /**
    * Log a message to the session timeline.

package/dist/telemetry.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Trace-context helpers.
+ *
+ * The SDK does not depend on any OpenTelemetry packages.  Instead, users
+ * provide an {@link TraceContextProvider} callback via client options.
+ *
+ * @module telemetry
+ */
+import type { TraceContext, TraceContextProvider } from "./types.js";
+/**
+ * Calls the user-provided {@link TraceContextProvider} to obtain the current
+ * W3C Trace Context.  Returns `{}` when no provider is configured.
+ */
+export declare function getTraceContext(provider?: TraceContextProvider): Promise<TraceContext>;

package/dist/telemetry.js

@@ -0,0 +1,11 @@
+async function getTraceContext(provider) {
+  if (!provider) return {};
+  try {
+    return await provider() ?? {};
+  } catch {
+    return {};
+  }
+}
+export {
+  getTraceContext
+};

package/dist/types.d.ts

@@ -6,6 +6,38 @@ export type SessionEvent = GeneratedSessionEvent;
 /**
  * Options for creating a CopilotClient
  */
+/**
+ * W3C Trace Context headers used for distributed trace propagation.
+ */
+export interface TraceContext {
+    traceparent?: string;
+    tracestate?: string;
+}
+/**
+ * Callback that returns the current W3C Trace Context.
+ * Wire this up to your OpenTelemetry (or other tracing) SDK to enable
+ * distributed trace propagation between your app and the Copilot CLI.
+ */
+export type TraceContextProvider = () => TraceContext | Promise<TraceContext>;
+/**
+ * Configuration for OpenTelemetry instrumentation.
+ *
+ * When provided via {@link CopilotClientOptions.telemetry}, the SDK sets
+ * the corresponding environment variables on the spawned CLI process so
+ * that the CLI's built-in OTel exporter is configured automatically.
+ */
+export interface TelemetryConfig {
+    /** OTLP HTTP endpoint URL for trace/metric export. Sets OTEL_EXPORTER_OTLP_ENDPOINT. */
+    otlpEndpoint?: string;
+    /** File path for JSON-lines trace output. Sets COPILOT_OTEL_FILE_EXPORTER_PATH. */
+    filePath?: string;
+    /** Exporter backend type: "otlp-http" or "file". Sets COPILOT_OTEL_EXPORTER_TYPE. */
+    exporterType?: string;
+    /** Instrumentation scope name. Sets COPILOT_OTEL_SOURCE_NAME. */
+    sourceName?: string;
+    /** Whether to capture message content (prompts, responses). Sets OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT. */
+    captureContent?: boolean;
+}
 export interface CopilotClientOptions {
     /**
      * Path to the CLI executable or JavaScript entry point.
@@ -83,6 +115,37 @@ export interface CopilotClientOptions {
      * available from your custom provider.
      */
     onListModels?: () => Promise<ModelInfo[]> | ModelInfo[];
+    /**
+     * OpenTelemetry configuration for the CLI process.
+     * When provided, the corresponding OTel environment variables are set
+     * on the spawned CLI server.
+     */
+    telemetry?: TelemetryConfig;
+    /**
+     * Advanced: callback that returns the current W3C Trace Context for distributed
+     * trace propagation.  Most users do not need this — the {@link telemetry} config
+     * alone is sufficient to collect traces from the CLI.
+     *
+     * This callback is only useful when your application creates its own
+     * OpenTelemetry spans and you want them to appear in the **same** distributed
+     * trace as the CLI's spans.  The SDK calls this before `session.create`,
+     * `session.resume`, and `session.send` RPCs to inject `traceparent`/`tracestate`
+     * into the request.
+     *
+     * @example
+     * ```typescript
+     * import { propagation, context } from "@opentelemetry/api";
+     *
+     * const client = new CopilotClient({
+     *   onGetTraceContext: () => {
+     *     const carrier: Record<string, string> = {};
+     *     propagation.inject(context.active(), carrier);
+     *     return carrier;
+     *   },
+     * });
+     * ```
+     */
+    onGetTraceContext?: TraceContextProvider;
 }
 /**
  * Configuration for creating a session
@@ -108,6 +171,10 @@ export interface ToolInvocation {
     toolCallId: string;
     toolName: string;
     arguments: unknown;
+    /** W3C Trace Context traceparent from the CLI's execute_tool span. */
+    traceparent?: string;
+    /** W3C Trace Context tracestate from the CLI's execute_tool span. */
+    tracestate?: string;
 }
 export type ToolHandler<TArgs = unknown> = (args: TArgs, invocation: ToolInvocation) => Promise<unknown> | unknown;
 /**
@@ -686,7 +753,7 @@ export interface MessageOptions {
      */
     prompt: string;
     /**
-     * File, directory, or selection attachments
+     * File, directory, selection, or blob attachments
      */
     attachments?: Array<{
         type: "file";
@@ -711,6 +778,11 @@ export interface MessageOptions {
             };
         };
         text?: string;
+    } | {
+        type: "blob";
+        data: string;
+        mimeType: string;
+        displayName?: string;
     }>;
     /**
      * Message delivery mode

package/package.json

@@ -4,18 +4,30 @@
     "type": "git",
     "url": "https://github.com/github/copilot-sdk.git"
   },
-  "version": "0.1.33-preview.1",
+  "version": "0.1.33-preview.3",
   "description": "TypeScript SDK for programmatic control of GitHub Copilot CLI via JSON-RPC",
-  "main": "./dist/index.js",
+  "main": "./dist/cjs/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
     },
     "./extension": {
-      "import": "./dist/extension.js",
-      "types": "./dist/extension.d.ts"
+      "import": {
+        "types": "./dist/extension.d.ts",
+        "default": "./dist/extension.js"
+      },
+      "require": {
+        "types": "./dist/extension.d.ts",
+        "default": "./dist/cjs/extension.js"
+      }
     }
   },
   "type": "module",