@github/copilot-sdk 1.0.14 → 1.0.15-preview.0

package/README.md

@@ -118,6 +118,7 @@ new CopilotClient(options?: CopilotClientOptions)
 - `mode?: "empty" | "copilot-cli"` - Defaulting strategy. Use `"empty"` for multi-user server mode; defaults to `"copilot-cli"`.
 - `workingDirectory?: string` - Working directory for the runtime process (default: current process cwd).
 - `baseDirectory?: string` - Base directory for Copilot data (session state, config, etc.). Sets `COPILOT_HOME` on the spawned runtime. When not set, the runtime defaults to `~/.copilot`. Ignored when connecting via `RuntimeConnection.forUri`.
+- `extensionLaunchProvider?: ExtensionLaunchProvider` - Experimental connection-level resolver for extension launch profiles. The client installs the reverse-RPC handler and registers the provider during startup before sessions can be created.
 - `logLevel?: "none" | "error" | "warning" | "info" | "debug" | "all"` - Log level. When omitted, the runtime uses its own default (currently `"info"`).
 - `env?: Record<string, string | undefined>` - Environment variables for the runtime process. When omitted, inherits `process.env`.
 - `gitHubToken?: string` - GitHub token for authentication. When provided, takes priority over other auth methods.
@@ -305,6 +306,87 @@ Send a message and wait until the session becomes idle.
 
 Returns the final assistant message event, or undefined if none was received.
 
+##### Structured output (preview)
+
+Requires a runtime build with `responseFormat` and `originatingMessageId` support.
+Pass a raw JSON Schema or a Zod schema as `responseSchema` to `send` or
+`sendAndWait`. As with custom tool parameters, the SDK converts Zod schemas to
+JSON Schema before sending them:
+
+```typescript
+import { z } from "zod";
+
+const answerSchema = z.object({ answer: z.number().int() });
+const message = await session.sendAndWait({
+    prompt: "What is 19 + 23?",
+    responseSchema: answerSchema,
+});
+console.log(message?.data.content); // JSON text
+```
+
+For a typed result, pass the Zod schema as the **second argument** instead:
+
+```typescript
+const answer = await session.sendAndWait("What is 19 + 23?", answerSchema);
+console.log(answer.answer); // number; TResult is inferred from answerSchema
+```
+
+`sendAndWait<TResult>(options, schema, timeout?)` generates the JSON Schema from
+the schema value, parses the final JSON, and validates it with the schema's
+`parse` method. TypeScript cannot derive a runtime schema from an erased type
+parameter alone. Invalid JSON, a schema mismatch, or a completed run without a
+matching assistant message throws. Do not also set `options.responseSchema` when
+using the typed overload.
+
+The schema belongs to the submitted run, including its tool-call iterations.
+Internally generated stop-hook corrections retain the schema and originating
+message ID, so the wait returns the corrected answer. Independent subsequent
+sends do not inherit it. Ordinary immediate steering inherits the active schema
+and originating message ID, even when it arrives too late for the current model
+request and is promoted into a follow-up run. Specifying a schema with
+`mode: "immediate"` is rejected, even while idle.
+The generated `session.rpc.send` and `session.rpc.sendMessages` wrappers expose
+the full `responseFormat` contract when you need to set its name, description,
+or strict option rather than using the convenience defaults (`name: "response"`,
+`strict: true`).
+Each batch starts one run: the final returned message ID is its origin, preceding
+messages are context, and an empty batch has no origin. An immediate batch
+steers the active run instead and retains its origin.
+The schema is not a persisted session default: autonomous resume-pending work
+after a restart does not restore it. A terminal tool that clears context ends
+the old run; its fresh seed does not inherit the schema or origin. Such a run
+can finish without a structured result, in which case the typed wait throws.
+After a successful terminal tool, the runtime disables tools while the model
+produces the structured result. Stop-hook corrections remain supported.
+Remote sessions and known HydraFusion routes reject response formats before
+admission. Schemas larger than 32 MiB when JSON-encoded are also rejected before
+admission, using the runtime's existing request-size ceiling. This does not
+guarantee the schema plus conversation and tools fits the provider's budget.
+
+Structured waits select the last root-agent message whose `originatingMessageId`
+matches the ID returned by their send, then return at a non-autopilot
+`session.idle`. Other queued work can delay that idle, but cannot replace the
+selected result. The existing unformatted overload retains its session-wide
+behavior. `turnId` identifies an individual model/tool iteration, not the whole
+run; telemetry interaction IDs are not unique run identifiers.
+
+For event-driven consumption with `send`, subscribe before sending and collect
+root `assistant.message` events whose `data.originatingMessageId` matches the ID
+returned by `send`; events may arrive before that acknowledgement. Wait for
+`session.idle`, then parse the last matching message without tool requests.
+An earlier response may be superseded by a stop-hook correction. Handle
+`session.error` and aborted idle events rather than returning a partial result.
+
+Streaming still delivers ordinary text events, including intermediate messages
+and tool calls. Only the final selected message is parsed by the typed overload;
+not every event is necessarily a complete schema-conforming JSON document.
+Provider errors, refusals, cancellation, truncation, session errors, and timeouts
+can prevent a typed result. A timeout stops waiting, not the runtime's work.
+Use a model and endpoint that support native structured output. An API-compatible
+gateway may ignore format fields even when it accepts the request; for example,
+the Claude Chat-completions compatibility route is not equivalent to Anthropic's
+native `output_config.format` endpoint.
+
 ##### `on(eventType: string, handler: TypedSessionEventHandler): () => void`
 
 Subscribe to a specific event type. The handler receives properly typed events.

package/dist/cjs/cliVersion.js

@@ -22,7 +22,7 @@ __export(cliVersion_exports, {
   COPILOT_CLI_VERSION: () => COPILOT_CLI_VERSION
 });
 module.exports = __toCommonJS(cliVersion_exports);
-const COPILOT_CLI_VERSION = "1.0.85";
+const COPILOT_CLI_VERSION = "1.0.87-0";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/client.js

@@ -45,13 +45,11 @@ var import_cliVersion = require("./cliVersion.js");
 var import_sessionFsProvider = require("./sessionFsProvider.js");
 var import_copilotRequestHandler = require("./copilotRequestHandler.js");
 var import_telemetry = require("./telemetry.js");
+var import_schema = require("./schema.js");
 var import_toolSet = require("./toolSet.js");
 var import_types = require("./types.js");
 const MIN_PROTOCOL_VERSION = 3;
 const RUNTIME_SHUTDOWN_TIMEOUT_MS = 1e4;
-function isZodSchema(value) {
-  return value != null && typeof value === "object" && "toJSONSchema" in value && typeof value.toJSONSchema === "function";
-}
 async function withTimeout(promise, timeoutMs, message) {
   let timeout;
   try {
@@ -96,13 +94,6 @@ async function waitForChildExit(child, timeoutMs) {
     }
   });
 }
-function toJsonSchema(parameters) {
-  if (!parameters) return void 0;
-  if (isZodSchema(parameters)) {
-    return parameters.toJSONSchema();
-  }
-  return parameters;
-}
 const DEFAULT_PROVIDER_NAME = "default";
 function extractBearerTokenProviders(provider, providers) {
   const callbacks = /* @__PURE__ */ new Map();
@@ -235,6 +226,7 @@ class CopilotClient {
   cliProcess = null;
   ffiHost = null;
   connection = null;
+  requestAdapter = null;
   messageWriter = null;
   connectionClosed = false;
   socket = null;
@@ -272,6 +264,7 @@ class CopilotClient {
   /** Connection-level session filesystem config, set via constructor option. */
   sessionFsConfig = null;
   requestHandler = null;
+  extensionLaunchProvider;
   builtinPluginDirectories = [];
   onGitHubTelemetry;
   clientGlobalHandlers = {};
@@ -429,6 +422,7 @@ class CopilotClient {
     this.onGetTraceContext = options.onGetTraceContext;
     this.sessionFsConfig = options.sessionFs ?? null;
     this.requestHandler = options.requestHandler ?? null;
+    this.extensionLaunchProvider = options.extensionLaunchProvider;
     this.onGitHubTelemetry = options.onGitHubTelemetry;
     this.setupClientGlobalHandlers();
     const connEnv = conn.kind === "stdio" || conn.kind === "tcp" ? conn.env : void 0;
@@ -531,14 +525,16 @@ class CopilotClient {
   }
   setupClientGlobalHandlers() {
     const handlers = {};
+    handlers.extensionLaunchProvider = this.extensionLaunchProvider;
     if (this.requestHandler) {
-      handlers.llmInference = (0, import_copilotRequestHandler.createCopilotRequestAdapter)(this.requestHandler, () => {
+      this.requestAdapter = (0, import_copilotRequestHandler.createCopilotRequestAdapter)(this.requestHandler, () => {
         if (!this.connection) {
           return void 0;
         }
         this._rpc ??= (0, import_rpc.createServerRpc)(this.connection);
         return this._rpc;
       });
+      handlers.llmInference = this.requestAdapter;
     }
     if (this.onGitHubTelemetry) {
       const onGitHubTelemetry = this.onGitHubTelemetry;
@@ -643,6 +639,9 @@ class CopilotClient {
       }
       await this.connectToServer();
       await this.verifyProtocolVersion();
+      if (this.extensionLaunchProvider) {
+        await this.rpc.registerExtensionLaunchProvider();
+      }
       if (this.builtinPluginDirectories.length > 0) {
         try {
           await this.connection.sendRequest("plugins.builtin.set", {
@@ -731,6 +730,7 @@ class CopilotClient {
     }
     this.sessions.clear();
     this.githubTokenProviders.clear();
+    this.requestAdapter?.cancelPending();
     if (this.connection && !this.connectionClosed && (this.cliProcess || this.ffiHost) && !this.isExternalServer) {
       const runtimeShutdownStart = Date.now();
       const shutdownPromise = this.rpc.runtime.shutdown();
@@ -886,6 +886,7 @@ class CopilotClient {
     }
     this.sessions.clear();
     this.githubTokenProviders.clear();
+    this.requestAdapter?.cancelPending();
     if (this.messageWriter) {
       this.messageWriter.suppressWriteErrors = true;
     }
@@ -1188,7 +1189,7 @@ class CopilotClient {
         tools: config.tools?.map((tool) => ({
           name: tool.name,
           description: tool.description,
-          parameters: toJsonSchema(tool.parameters),
+          parameters: (0, import_schema.toJsonSchema)(tool.parameters),
           overridesBuiltInTool: tool.overridesBuiltInTool,
           skipPermission: tool.skipPermission,
           defer: tool.defer,
@@ -1432,7 +1433,7 @@ class CopilotClient {
         tools: config.tools?.map((tool) => ({
           name: tool.name,
           description: tool.description,
-          parameters: toJsonSchema(tool.parameters),
+          parameters: (0, import_schema.toJsonSchema)(tool.parameters),
           overridesBuiltInTool: tool.overridesBuiltInTool,
           skipPermission: tool.skipPermission,
           defer: tool.defer,
@@ -2294,6 +2295,7 @@ stderr: ${stderrOutput}` : ""}`
       }
       this.sessions.clear();
       this.githubTokenProviders.clear();
+      this.requestAdapter?.cancelPending();
     };
     this.connection.onClose(markDisconnected);
     this.connection.onError(() => {

package/dist/cjs/copilotRequestHandler.js

@@ -27,6 +27,7 @@ __export(copilotRequestHandler_exports, {
 module.exports = __toCommonJS(copilotRequestHandler_exports);
 const sharedTextDecoder = new TextDecoder("utf-8", { fatal: false });
 const sharedTextEncoder = new TextEncoder();
+const HTTP_RESPONSE_READ_AHEAD_BYTES = 32 * 1024;
 const kBridge = /* @__PURE__ */ Symbol("copilotWebSocketResponseBridge");
 const kCompletion = /* @__PURE__ */ Symbol("copilotWebSocketCompletion");
 const kOpen = /* @__PURE__ */ Symbol("copilotWebSocketOpen");
@@ -265,7 +266,9 @@ function createCopilotRequestAdapter(handler, getServerRpc) {
       const message = err instanceof Error ? err.message : String(err);
       await finalize(exchange, 502, message);
     } finally {
-      pending.delete(exchange.requestId);
+      if (pending.get(exchange.requestId) === exchange) {
+        pending.delete(exchange.requestId);
+      }
     }
   }
   return {
@@ -278,6 +281,13 @@ function createCopilotRequestAdapter(handler, getServerRpc) {
     async httpRequestChunk(params) {
       routeChunk(getOrCreate(params.requestId), params);
       return {};
+    },
+    cancelPending() {
+      const exchanges = [...pending.values()];
+      pending.clear();
+      for (const exchange of exchanges) {
+        exchange.pushCancel("RPC connection closed");
+      }
     }
   };
 }
@@ -526,30 +536,156 @@ async function drainAsync(stream) {
   return out;
 }
 async function streamResponse(response, exchange) {
-  await exchange.startResponse({
-    status: response.status,
-    statusText: response.statusText || void 0,
-    headers: headersToMultiMap(response.headers)
-  });
-  const body = response.body;
-  if (!body) {
-    await exchange.endResponse();
-    return;
-  }
-  const reader = body.getReader();
+  const reader = response.body ? new HttpResponseReader(response.body, exchange.signal) : void 0;
   try {
-    for (; ; ) {
-      const { value, done } = await reader.read();
-      if (done) {
-        break;
-      }
-      if (value && value.byteLength > 0) {
-        await exchange.writeResponse(value);
+    await exchange.startResponse({
+      status: response.status,
+      statusText: response.statusText || void 0,
+      headers: headersToMultiMap(response.headers)
+    });
+    if (reader) {
+      for (; ; ) {
+        const chunk = await reader.nextChunk();
+        if (!chunk) {
+          break;
+        }
+        await exchange.writeResponse(chunk);
       }
     }
     await exchange.endResponse();
   } finally {
-    reader.releaseLock();
+    await reader?.dispose();
+  }
+}
+class HttpResponseReader {
+  #reader;
+  #signal;
+  #frames = [];
+  #pump;
+  #onAbort;
+  #queued = 0;
+  #done = false;
+  #cancelled = false;
+  #hasError = false;
+  #error;
+  #dataWaker;
+  #spaceWaker;
+  #cancelPromise;
+  constructor(body, signal) {
+    this.#reader = body.getReader();
+    this.#signal = signal;
+    this.#onAbort = () => {
+      void this.cancel(signal.reason);
+    };
+    signal.addEventListener("abort", this.#onAbort, { once: true });
+    this.#pump = this.#pumpSource();
+    if (signal.aborted) {
+      this.#onAbort();
+    }
+  }
+  async nextChunk() {
+    while (this.#frames.length === 0 && !this.#done && !this.#hasError) {
+      await new Promise((resolve) => {
+        this.#dataWaker = resolve;
+      });
+    }
+    if (this.#frames.length > 0) {
+      const chunk = this.#takeQueued();
+      this.#wakeSpace();
+      return chunk;
+    }
+    if (this.#hasError) {
+      this.#hasError = false;
+      throw this.#error;
+    }
+    return void 0;
+  }
+  #takeQueued() {
+    const frames = this.#frames;
+    const total = this.#queued;
+    this.#queued = 0;
+    if (frames.length === 1) {
+      return frames.pop();
+    }
+    const chunk = new Uint8Array(total);
+    let offset = 0;
+    for (const frame of frames) {
+      chunk.set(frame, offset);
+      offset += frame.byteLength;
+    }
+    frames.length = 0;
+    return chunk;
+  }
+  async dispose() {
+    this.#signal.removeEventListener("abort", this.#onAbort);
+    if (!this.#done) {
+      await this.cancel();
+    } else if (this.#cancelPromise) {
+      await this.#cancelPromise;
+    }
+    await this.#pump;
+  }
+  cancel(reason) {
+    if (this.#done) {
+      return Promise.resolve();
+    }
+    if (!this.#cancelPromise) {
+      this.#cancelled = true;
+      this.#done = true;
+      this.#hasError = true;
+      this.#error = reason instanceof Error ? reason : new Error("HTTP response body cancelled.");
+      this.#frames.length = 0;
+      this.#queued = 0;
+      this.#wakeData();
+      this.#wakeSpace();
+      this.#cancelPromise = this.#reader.cancel(reason).catch(() => void 0);
+    }
+    return this.#cancelPromise;
+  }
+  async #pumpSource() {
+    try {
+      while (!this.#cancelled) {
+        while (this.#queued >= HTTP_RESPONSE_READ_AHEAD_BYTES && !this.#cancelled) {
+          await new Promise((resolve) => {
+            this.#spaceWaker = resolve;
+          });
+        }
+        if (this.#cancelled) {
+          return;
+        }
+        const { value, done } = await this.#reader.read();
+        if (done) {
+          return;
+        }
+        if (value.byteLength > 0) {
+          this.#frames.push(value);
+          this.#queued += value.byteLength;
+          this.#wakeData();
+          continue;
+        }
+        await new Promise((resolve) => setImmediate(resolve));
+      }
+    } catch (error) {
+      if (!this.#cancelled) {
+        this.#hasError = true;
+        this.#error = error;
+      }
+    } finally {
+      this.#done = true;
+      this.#wakeData();
+      this.#wakeSpace();
+      this.#reader.releaseLock();
+    }
+  }
+  #wakeData() {
+    const waker = this.#dataWaker;
+    this.#dataWaker = void 0;
+    waker?.();
+  }
+  #wakeSpace() {
+    const waker = this.#spaceWaker;
+    this.#spaceWaker = void 0;
+    waker?.();
   }
 }
 function headersToMultiMap(headers) {