@agentknight/sdk 0.9.43 → 0.9.45

package/dist/index.js

@@ -4,12 +4,12 @@ import {
   PeerChatRequestSchema,
   PeerChatResultSchema,
   validateDataDirectory
-} from "./chunks/chunk-M2QZ6EFR.js";
+} from "./chunks/chunk-GRXWNM6S.js";
 import {
   AgentSelectionSchema,
   assertSelectionSnapshotFits,
   supportsAgentSelection
-} from "./chunks/chunk-YZ2GB3DD.js";
+} from "./chunks/chunk-DCY33KQC.js";
 import {
   ConversationNormalizer,
   LiveTimelineProjection,
@@ -31,11 +31,11 @@ import {
   resolveGitProjectIdentity,
   sessionRestoreFailure,
   validateOperationResponse
-} from "./chunks/chunk-CWJENQ3O.js";
+} from "./chunks/chunk-WAY4EXDI.js";
 import {
   GROUP_CHAT_MAX_TURNS,
   GroupChatError
-} from "./chunks/chunk-C2VUD77E.js";
+} from "./chunks/chunk-OPUBIQCO.js";
 import {
   detectClaude,
   detectCopilot,
@@ -46,7 +46,7 @@ import {
   assistantPreview,
   isContentfulAssistant,
   userPreview
-} from "./chunks/chunk-DB3EAMYS.js";
+} from "./chunks/chunk-QBKKQQCB.js";
 import {
   AgentModelListingError,
   AgentSessionRenameError,
@@ -57,7 +57,7 @@ import {
   UnsupportedAgentOperationError,
   captureResearchAccess,
   captureWorkbenchAccess
-} from "./chunks/chunk-ULM5KUJ7.js";
+} from "./chunks/chunk-7A2SQAZ7.js";
 import {
   A2aRelayRequestSchema,
   A2aRelayResponseSchema,
@@ -131,6 +131,7 @@ import {
   SESSION_GIT_DIFF_MAX_PATCH_BYTES,
   SESSION_GIT_DIFF_MAX_RESPONSE_BYTES,
   SESSION_GIT_DIFF_OPERATION,
+  SESSION_GIT_DIFF_PARTIAL_VERSION,
   SESSION_GIT_DIFF_VERSION,
   SESSION_IMAGE_API_PATH,
   SESSION_IMAGE_MAX_BYTES,
@@ -169,6 +170,7 @@ import {
   SessionFileReadV2ResultDataSchema,
   SessionGitDiffDataSchema,
   SessionGitDiffGzipResultDataSchema,
+  SessionGitDiffPartialResultDataSchema,
   SessionGitDiffResultDataSchema,
   SessionImageCommitResultSchema,
   SessionImageScopeSchema,
@@ -239,7 +241,7 @@ import {
   sessionCommunicationError,
   sessionCommunicationOperationCapability,
   workbenchCapability
-} from "./chunks/chunk-7QOBDG6R.js";
+} from "./chunks/chunk-DUMC5F2D.js";
 
 // src/initialize.ts
 import { createHash as createHash16 } from "node:crypto";
@@ -277,7 +279,7 @@ async function createCodingAgentAdapter(config, onDiagnostic, owner) {
   switch (engine.kind) {
     case "managed": {
       if (owner === void 0) throw new Error("Managed coding agents require the PC owner identity");
-      const { ManagedCodingAgentAdapter } = await import("./chunks/managed-agent-adapter-ZXTKIPJN.js");
+      const { ManagedCodingAgentAdapter } = await import("./chunks/managed-agent-adapter-UYLBGRNG.js");
       return new ManagedCodingAgentAdapter({
         dataDirectory: config.dataDirectory,
         owner,
@@ -334,7 +336,7 @@ async function createCodingAgentAdapter(config, onDiagnostic, owner) {
       });
     }
     case "copilot": {
-      const { GithubCopilotAdapter } = await import("./chunks/copilot-adapter-UP6KDSXH.js");
+      const { GithubCopilotAdapter } = await import("./chunks/copilot-adapter-6PV52BVH.js");
       if (owner !== void 0) {
         return new GithubCopilotAdapter(void 0, void 0, void 0, {
           dataDirectory: config.dataDirectory,
@@ -354,13 +356,13 @@ async function createCodingAgentAdapter(config, onDiagnostic, owner) {
     }
     case "pi": {
       assertPiRuntimeSupported();
-      const { PiCodingAgentAdapter } = await import("./chunks/pi-adapter-KXVZ5QP5.js");
+      const { PiCodingAgentAdapter } = await import("./chunks/pi-adapter-5PZT5YQN.js");
       return new PiCodingAgentAdapter(
         engine.agentDirectory === void 0 ? {} : { agentDirectory: resolve(engine.agentDirectory) }
       );
     }
     case "codex": {
-      const { CodexCodingAgentAdapter } = await import("./chunks/codex-adapter-VQTLTFNP.js");
+      const { CodexCodingAgentAdapter } = await import("./chunks/codex-adapter-IR5E7AMV.js");
       return new CodexCodingAgentAdapter({
         dataDirectory: resolve(config.dataDirectory, "coding-agents"),
         ...engine.command === void 0 ? {} : { command: engine.command },
@@ -368,14 +370,14 @@ async function createCodingAgentAdapter(config, onDiagnostic, owner) {
       });
     }
     case "claude": {
-      const { ClaudeCodingAgentAdapter } = await import("./chunks/claude-adapter-7VQ4QCNI.js");
+      const { ClaudeCodingAgentAdapter } = await import("./chunks/claude-adapter-CBEKRKPT.js");
       return new ClaudeCodingAgentAdapter({
         dataDirectory: resolve(config.dataDirectory, "coding-agents"),
         ...onDiagnostic === void 0 ? {} : { onDiagnostic }
       });
     }
     case "acp": {
-      const { AcpCodingAgentAdapter } = await import("./chunks/acp-adapter-LJNYHSSY.js");
+      const { AcpCodingAgentAdapter } = await import("./chunks/acp-adapter-3CQCDP5H.js");
       return new AcpCodingAgentAdapter({
         command: engine.command,
         args: engine.args,
@@ -2690,6 +2692,28 @@ var SessionGitDiffError = class extends Error {
 function fail3(code, message) {
   throw new SessionGitDiffError(code, message);
 }
+function fileError(error) {
+  if (error instanceof SessionGitDiffError && error.code === "DIFF_BLOCKED") {
+    return { code: "DIFF_BLOCKED", message: error.message };
+  }
+  if (error instanceof Error && "code" in error && typeof error.code === "string" && ["EACCES", "EPERM", "EBUSY", "ENAMETOOLONG", "EINVAL", "EIO", "ELOOP"].includes(error.code)) {
+    return { code: "DIFF_FILE_UNAVAILABLE", message: `Cannot read this path (${error.code})` };
+  }
+  return void 0;
+}
+async function forFile(path, work, operation) {
+  try {
+    return await operation();
+  } catch (error) {
+    const failure = work.partial ? fileError(error) : void 0;
+    if (failure === void 0) throw error;
+    throw new SessionGitDiffError(
+      failure.code === "DIFF_BLOCKED" ? "DIFF_FILE_BLOCKED" : failure.code,
+      `${path}: ${failure.message}`,
+      { cause: error }
+    );
+  }
+}
 function changed() {
   return fail3("DIFF_CHANGED", "The project diff changed; refresh the changed-file list");
 }
@@ -2725,12 +2749,30 @@ function environment() {
 function isExit(error, code) {
   return error instanceof Error && "code" in error && error.code === code && "stdout" in error && Buffer.isBuffer(error.stdout) && "stderr" in error && Buffer.isBuffer(error.stderr);
 }
+function hashFileError(error, path) {
+  if (!isExit(error, 128)) return void 0;
+  const diagnostic = decode(error.stderr).trim().split(/\r?\n/u).at(-1) ?? "";
+  if (!diagnostic.startsWith(`fatal: could not open '${path}' for reading: `)) return void 0;
+  return { code: "DIFF_FILE_UNAVAILABLE", message: "Cannot normalize this path for comparison" };
+}
 var Work = class {
+  constructor(partial) {
+    this.partial = partial;
+  }
+  partial;
   deadline = Date.now() + SESSION_GIT_DIFF_TIMEOUT_MS;
   env = environment();
   bytes = 0;
+  linkFiles = /* @__PURE__ */ new Set();
+  symlinks = true;
   #filterConfig = [];
   async disableExternalFilters(repository) {
+    this.symlinks = decode(await this.git(repository, [
+      "config",
+      "--type=bool",
+      "--get",
+      "core.symlinks"
+    ], { allowExitOne: true })).trim() !== "false";
     const names = records(await this.git(repository, [
       "config",
       "--includes",
@@ -2836,8 +2878,22 @@ async function inspect(root, path, work, kind = "file") {
   return void 0;
 }
 async function readCurrent(root, path, algorithm, work, keepBytes = false) {
-  const before = await inspect(root, path, work);
+  const kind = work.partial ? "link" : "file";
+  const before = await inspect(root, path, work, kind);
   if (before === void 0) return void 0;
+  if (before.isSymbolicLink()) {
+    const bytes = Buffer.from(await readlink(join5(root, ...path.split("/"))), "utf8");
+    const latest = await inspect(root, path, work, "link");
+    if (latest === void 0 || identity(latest) !== identity(before)) changed();
+    const oid = createHash5(algorithm).update(`blob ${bytes.length}\0`).update(bytes).digest("hex");
+    return {
+      oid,
+      rawOid: oid,
+      identity: identity(before),
+      mode: "120000",
+      ...keepBytes ? { bytes } : {}
+    };
+  }
   if (before.size > BigInt(MAX_SCAN_BYTES - work.bytes) || keepBytes && before.size > BigInt(SESSION_GIT_DIFF_MAX_SOURCE_BYTES)) limit();
   work.bytes += Number(before.size);
   const handle = await open2(
@@ -2867,7 +2923,7 @@ async function readCurrent(root, path, algorithm, work, keepBytes = false) {
       oid: rawOid,
       rawOid,
       identity: identity(before),
-      mode: process.platform !== "win32" && (before.mode & 0o111n) !== 0n ? "100755" : "100644",
+      mode: work.linkFiles.has(path) ? "120000" : process.platform !== "win32" && (before.mode & 0o111n) !== 0n ? "100755" : "100644",
       ...keepBytes ? { bytes: Buffer.concat(chunks) } : {}
     };
   } finally {
@@ -2903,7 +2959,6 @@ function scopedPath(context, path) {
   const prefix = context.prefix === "" ? "" : `${context.prefix}/`;
   if (!path.startsWith(prefix)) fail3("DIFF_BLOCKED", "Git returned a path outside the session");
   const scoped = path.slice(prefix.length);
-  if (!safePath(scoped)) fail3("DIFF_BLOCKED", "The project contains an unsupported path");
   return scoped;
 }
 function records(output2) {
@@ -2934,7 +2989,7 @@ async function changes(context, work) {
     return scoped2;
   };
   for (const record of tree) {
-    const match = /^(\d{6}) (blob|commit) ([a-f0-9]{40}|[a-f0-9]{64})\t(.+)$/u.exec(record);
+    const match = /^(\d{6}) (blob|commit) ([a-f0-9]{40}|[a-f0-9]{64})\t([\s\S]+)$/u.exec(record);
     if (!match?.[1] || !match[3] || !match[4]) fail3("DIFF_UNAVAILABLE", "Git returned an invalid tree");
     blobs.set(scoped(match[4]), { mode: match[1], oid: match[3] });
   }
@@ -2946,7 +3001,7 @@ async function changes(context, work) {
     "--",
     ...paths
   ]))) {
-    const match = /^(\d{6}) ([a-f0-9]{40}|[a-f0-9]{64}) [0-3]\t(.+)$/u.exec(record);
+    const match = /^(\d{6}) ([a-f0-9]{40}|[a-f0-9]{64}) [0-3]\t([\s\S]+)$/u.exec(record);
     if (!match?.[1] || !match[2] || !match[3]) fail3("DIFF_UNAVAILABLE", "Git returned an invalid index");
     tracked.set(scoped(match[3]), { mode: match[1], oid: match[2] });
   }
@@ -2985,38 +3040,88 @@ async function changes(context, work) {
     files: untracked
   }), "utf8") > SESSION_GIT_DIFF_MAX_RESPONSE_BYTES) limit();
   const result = [];
+  const errors = /* @__PURE__ */ new Map();
   const algorithm = context.baseCommit.length === 64 ? "sha256" : "sha1";
   const currentFiles = /* @__PURE__ */ new Map();
+  if (work.partial && !work.symlinks) {
+    for (const [path, blob] of tracked) if (blob.mode === "120000") work.linkFiles.add(path);
+  }
   for (const path of [...candidates].sort()) {
     work.check();
-    const original = blobs.get(path);
-    const indexed = tracked.get(path);
-    if ([original?.mode, indexed?.mode].some((mode) => mode !== void 0 && mode !== "100644" && mode !== "100755")) {
-      await unchangedSpecial(context, path, original, indexed, work);
-      candidates.delete(path);
-      continue;
+    try {
+      if (!safePath(path)) fail3("DIFF_BLOCKED", "This path cannot be safely accessed on the PC");
+      const original = blobs.get(path);
+      const indexed = tracked.get(path);
+      if ([original?.mode, indexed?.mode].some((mode) => mode !== void 0 && mode !== "100644" && mode !== "100755" && !(work.partial && mode === "120000"))) {
+        await unchangedSpecial(context, path, original, indexed, work);
+        candidates.delete(path);
+        continue;
+      }
+      const current = await readCurrent(context.root, path, algorithm, work);
+      if (current !== void 0) currentFiles.set(path, current);
+    } catch (error) {
+      const failure = fileError(error);
+      if (failure === void 0) throw error;
+      errors.set(path, failure);
     }
-    const current = await readCurrent(context.root, path, algorithm, work);
-    if (current !== void 0) currentFiles.set(path, current);
   }
-  if (currentFiles.size > 0) {
-    const hashes = decode(await work.git(context.repository, ["hash-object", "--stdin-paths"], {
-      input: [...currentFiles.keys()].map((path) => [context.prefix, path].filter(Boolean).join("/")).join("\n") + "\n"
-    })).trim().split("\n");
-    if (hashes.length !== currentFiles.size) changed();
-    for (const [index, [path, current]] of [...currentFiles].entries()) {
-      const oid = hashes[index];
-      if (!oid || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u.test(oid)) changed();
-      const latest = await inspect(context.root, path, work);
-      if (latest === void 0 || identity(latest) !== current.identity) changed();
-      current.oid = oid;
+  const regularFiles = [...currentFiles].filter(([, current]) => current.mode !== "120000");
+  if (regularFiles.length > 0) {
+    let hashes;
+    try {
+      hashes = decode(await work.git(context.repository, ["hash-object", "--stdin-paths"], {
+        input: regularFiles.map(([path]) => JSON.stringify([context.prefix, path].filter(Boolean).join("/"))).join("\n") + "\n"
+      })).trim().split("\n");
+    } catch (error) {
+      if (!work.partial || !isExit(error, 128) || regularFiles.length > SESSION_GIT_DIFF_MAX_FILES) throw error;
+      hashes = [];
+      for (const [path] of regularFiles) {
+        const repositoryPath = [context.prefix, path].filter(Boolean).join("/");
+        try {
+          hashes.push(decode(await work.git(context.repository, ["hash-object", "--stdin-paths"], {
+            input: JSON.stringify(repositoryPath) + "\n"
+          })).trim());
+        } catch (error2) {
+          const failure = hashFileError(error2, repositoryPath);
+          if (failure === void 0) throw error2;
+          errors.set(path, failure);
+          currentFiles.delete(path);
+          hashes.push("");
+        }
+      }
+    }
+    if (hashes.length !== regularFiles.length) changed();
+    for (const [index, [path, current]] of regularFiles.entries()) {
+      if (errors.has(path)) continue;
+      try {
+        const oid = hashes[index];
+        if (!oid || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u.test(oid)) changed();
+        const latest = await inspect(context.root, path, work);
+        if (latest === void 0 || identity(latest) !== current.identity) changed();
+        current.oid = oid;
+      } catch (error) {
+        const failure = work.partial ? fileError(error) : void 0;
+        if (failure === void 0) throw error;
+        errors.set(path, failure);
+        currentFiles.delete(path);
+      }
     }
   }
   for (const path of [...candidates].sort()) {
     const original = blobs.get(path);
     const current = currentFiles.get(path);
+    const error = errors.get(path);
+    if (error !== void 0) {
+      result.push({
+        entry: { path, status: original === void 0 ? tracked.has(path) ? "added" : "untracked" : tracked.has(path) ? "modified" : "deleted", error },
+        base: original,
+        current: void 0
+      });
+      if (result.length > SESSION_GIT_DIFF_MAX_FILES) limit();
+      continue;
+    }
     if (original === void 0 && current === void 0) continue;
-    if (original?.oid === current?.oid && (process.platform === "win32" || original?.mode === current?.mode)) continue;
+    if (original?.oid === current?.oid && original?.mode === "120000" === (current?.mode === "120000") && (process.platform === "win32" || original?.mode === current?.mode)) continue;
     result.push({
       entry: { path, status: original === void 0 ? tracked.has(path) ? "added" : "untracked" : current === void 0 ? "deleted" : "modified" },
       base: original,
@@ -3068,7 +3173,20 @@ async function patch(context, change, work, scratchDirectory) {
   if (current?.rawOid !== change.current?.rawOid || current?.mode !== change.current?.mode) changed();
   let original = Buffer.alloc(0);
   if (change.base !== void 0) {
-    const size = Number(decode(await work.git(context.repository, ["cat-file", "-s", change.base.oid])).trim());
+    let sizeBytes;
+    try {
+      sizeBytes = await work.git(context.repository, ["cat-file", "-s", change.base.oid]);
+    } catch (error) {
+      if (work.partial && isExit(error, 128) && decode(error.stderr).trim() === "fatal: git cat-file: could not get object info") {
+        throw new SessionGitDiffError(
+          "DIFF_FILE_UNAVAILABLE",
+          `${change.entry.path}: The base version of this file is unavailable`,
+          { cause: error }
+        );
+      }
+      throw error;
+    }
+    const size = Number(decode(sizeBytes).trim());
     if (!Number.isSafeInteger(size) || size < 0 || size > SESSION_GIT_DIFF_MAX_SOURCE_BYTES) limit();
     original = await work.git(context.repository, ["cat-file", "blob", change.base.oid], { maxBuffer: size + 1 });
     if (original.length !== size) changed();
@@ -3086,7 +3204,7 @@ async function patch(context, change, work, scratchDirectory) {
   let text;
   try {
     let bytes = current?.bytes ?? Buffer.alloc(0);
-    if (current !== void 0) {
+    if (current !== void 0 && current.mode !== "120000") {
       const objectDirectory = join5(scratch, "objects");
       await mkdir2(objectDirectory);
       const path = [context.prefix, change.entry.path].filter(Boolean).join("/");
@@ -3134,6 +3252,18 @@ async function patch(context, change, work, scratchDirectory) {
   } finally {
     await rm(scratch, { recursive: true, force: true, maxRetries: 3 });
   }
+  if (current?.mode === "120000" || change.base?.mode === "120000") {
+    text = text.replace(/^new file mode \d+$/mu, `new file mode ${current?.mode}`).replace(/^deleted file mode \d+$/mu, `deleted file mode ${change.base?.mode}`);
+    if (current !== void 0 && change.base !== void 0 && current.mode !== change.base.mode) {
+      text = text.replace(/^old mode \d+\nnew mode \d+\n/mu, "");
+      if (text === "") text = `diff --git a/${change.entry.path} b/${change.entry.path}
+`;
+      const end = text.indexOf("\n") + 1;
+      text = `${text.slice(0, end)}old mode ${change.base.mode}
+new mode ${current.mode}
+${text.slice(end)}`;
+    }
+  }
   if (Buffer.byteLength(text, "utf8") > SESSION_GIT_DIFF_MAX_PATCH_BYTES) limit();
   return { patch: text, binary: false };
 }
@@ -3145,14 +3275,14 @@ var SessionGitDiffReader = class {
   metadata;
   scratchDirectory;
   #active = 0;
-  async read(sessionId, data) {
+  async read(sessionId, data, version = SESSION_GIT_DIFF_PARTIAL_VERSION) {
     if (!SessionGitDiffDataSchema.safeParse(data).success || data.path !== void 0 && !safePath(data.path)) {
       fail3("INVALID_DIFF_PATH", "The project diff request is invalid");
     }
     if (this.#active >= SESSION_GIT_DIFF_CONCURRENCY) fail3("DIFF_BUSY", "Too many project diff requests");
     this.#active++;
-    const work = new Work();
-    const pending = this.#read(sessionId, data, work).finally(() => {
+    const work = new Work(version >= SESSION_GIT_DIFF_PARTIAL_VERSION);
+    const pending = this.#read(sessionId, data, work, version).finally(() => {
       this.#active--;
     });
     let timer;
@@ -3225,7 +3355,7 @@ var SessionGitDiffReader = class {
       ...await base(repository, work)
     };
   }
-  async #read(sessionId, data, work) {
+  async #read(sessionId, data, work, version) {
     const context = await this.#context(sessionId, data.rootRevision, work);
     if (data.baseCommit !== void 0 && data.baseCommit !== context.baseCommit) changed();
     await work.disableExternalFilters(context.repository);
@@ -3238,7 +3368,23 @@ var SessionGitDiffReader = class {
     } else {
       selected = files.find(({ entry }) => entry.path === data.path);
       if (selected === void 0) changed();
-      result = { ...common, path: data.path, ...await patch(context, selected, work, this.scratchDirectory) };
+      if (selected.entry.error !== void 0) {
+        const error = selected.entry.error;
+        fail3(
+          work.partial && error.code === "DIFF_BLOCKED" ? "DIFF_FILE_BLOCKED" : error.code,
+          `${data.path}: ${error.message}`
+        );
+      }
+      const change = selected;
+      result = {
+        ...common,
+        path: data.path,
+        ...await forFile(data.path, work, () => patch(context, change, work, this.scratchDirectory))
+      };
+    }
+    if (version < SESSION_GIT_DIFF_PARTIAL_VERSION) {
+      const blocked = files.find(({ entry }) => entry.error !== void 0)?.entry;
+      if (blocked?.error !== void 0) fail3(blocked.error.code, `${blocked.path}: ${blocked.error.message}`);
     }
     let latest;
     try {
@@ -3257,17 +3403,18 @@ var SessionGitDiffReader = class {
     }
     if (latest.repositoryIdentity !== context.repositoryIdentity || latest.baseRef !== context.baseRef || latest.baseCommit !== context.baseCommit) changed();
     if (selected !== void 0) {
-      const current = await readCurrent(
+      const path = selected.entry.path;
+      const current = await forFile(path, work, () => readCurrent(
         context.root,
-        selected.entry.path,
+        path,
         context.baseCommit.length === 64 ? "sha256" : "sha1",
         work
-      );
+      ));
       if (current?.rawOid !== selected.current?.rawOid || current?.mode !== selected.current?.mode) changed();
     }
     work.check();
     if (Buffer.byteLength(JSON.stringify(result), "utf8") > SESSION_GIT_DIFF_MAX_RESPONSE_BYTES) limit();
-    return SessionGitDiffResultDataSchema.parse(result);
+    return (version >= SESSION_GIT_DIFF_PARTIAL_VERSION ? SessionGitDiffPartialResultDataSchema : SessionGitDiffResultDataSchema).parse(result);
   }
 };
 
@@ -3783,16 +3930,16 @@ function createCommunicationOperations(options) {
     ],
     ...options.incrementalOperations,
     ...adapter.getSessionDirectoryMetadata === void 0 ? [] : [
-      ...[SESSION_GIT_DIFF_VERSION, SESSION_GIT_DIFF_GZIP_VERSION].map((version) => sessionCommunicationOperation({
+      ...[SESSION_GIT_DIFF_VERSION, SESSION_GIT_DIFF_GZIP_VERSION, SESSION_GIT_DIFF_PARTIAL_VERSION].map((version) => sessionCommunicationOperation({
         operation: SESSION_GIT_DIFF_OPERATION,
         version,
         schema: SessionGitDiffDataSchema,
         handle: async (data, request) => {
           const assertAccess = options.captureRequestAccess();
           assertAccess();
-          const result = await gitDiffReader.read(request.sessionId, data);
+          const result = await gitDiffReader.read(request.sessionId, data, version);
           let response = SessionCommunicationDataSchema.parse(result);
-          if (version === SESSION_GIT_DIFF_GZIP_VERSION) {
+          if (version >= SESSION_GIT_DIFF_GZIP_VERSION) {
             const bytes = Buffer.from(JSON.stringify(result), "utf8");
             if (bytes.length >= SESSION_GIT_DIFF_GZIP_MIN_BYTES) {
               response = SessionGitDiffGzipResultDataSchema.parse({

package/dist/runtime.js

@@ -3,8 +3,8 @@ import {
   PEER_CHAT_TIMEOUT_MS,
   PeerChatRequestSchema,
   PeerChatResultSchema
-} from "./chunks/chunk-M2QZ6EFR.js";
-import "./chunks/chunk-7QOBDG6R.js";
+} from "./chunks/chunk-GRXWNM6S.js";
+import "./chunks/chunk-DUMC5F2D.js";
 export {
   DataDirectoryLease,
   PEER_CHAT_TIMEOUT_MS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentknight/sdk",
-  "version": "0.9.43",
+  "version": "0.9.45",
   "description": "AgentKnight runtime SDK for local and remote coding sessions",
   "license": "Apache-2.0",
   "type": "module",