@kilocode/sdk 7.7.3 → 7.7.5

package/dist/kilocode/permission.d.ts

@@ -0,0 +1,26 @@
+import type { KiloClient } from "../v2/client.js";
+type Decision = {
+    requestID: string;
+    directory: string;
+    reply: "once" | "always" | "reject";
+    approvedAlways: string[];
+    deniedAlways: string[];
+    message?: string;
+};
+/**
+ * Send a permission decision with one bounded wait across both requests.
+ * A timeout aborts only the client wait, so callers must reconcile an aborted
+ * rule save because the server may still persist the rules.
+ * Rules are saved first so a failed save never continues to the reply.
+ */
+export declare function respondToPermission(client: KiloClient, input: Decision, timeout?: number): Promise<{
+    error?: unknown;
+    saved?: boolean;
+}>;
+/**
+ * An aborted rule save can still complete on the server. A request that is no
+ * longer pending was applied, so the caller must not offer a retry that could
+ * persist a conflicting rule. Returns false when the outcome stays unknown.
+ */
+export declare function permissionSettled(client: KiloClient, directory: string, requestID: string, timeout?: number): Promise<boolean>;
+export {};

package/dist/kilocode/permission.js

@@ -0,0 +1,43 @@
+/**
+ * Send a permission decision with one bounded wait across both requests.
+ * A timeout aborts only the client wait, so callers must reconcile an aborted
+ * rule save because the server may still persist the rules.
+ * Rules are saved first so a failed save never continues to the reply.
+ */
+export async function respondToPermission(client, input, timeout = 15_000) {
+    const deadline = Date.now() + timeout;
+    const budget = () => Math.max(0, deadline - Date.now());
+    const saved = input.approvedAlways.length > 0 || input.deniedAlways.length > 0;
+    try {
+        if (saved) {
+            await client.permission.saveAlwaysRules({
+                requestID: input.requestID,
+                directory: input.directory,
+                approvedAlways: input.approvedAlways,
+                deniedAlways: input.deniedAlways,
+            }, { throwOnError: true, signal: AbortSignal.timeout(budget()) });
+        }
+        await client.permission.reply({
+            requestID: input.requestID,
+            directory: input.directory,
+            reply: input.reply,
+            interactive: true,
+            ...(input.message ? { message: input.message } : {}),
+        }, { throwOnError: true, signal: AbortSignal.timeout(budget()) });
+        return { saved };
+    }
+    catch (error) {
+        return { error, saved };
+    }
+}
+/**
+ * An aborted rule save can still complete on the server. A request that is no
+ * longer pending was applied, so the caller must not offer a retry that could
+ * persist a conflicting rule. Returns false when the outcome stays unknown.
+ */
+export async function permissionSettled(client, directory, requestID, timeout = 5_000) {
+    const { data, error } = await client.permission.list({ directory }, { signal: AbortSignal.timeout(timeout) });
+    if (error || !data)
+        return false;
+    return !data.some((permission) => permission.id === requestID);
+}

package/dist/v2/gen/types.gen.d.ts

@@ -2025,6 +2025,7 @@ export type Config = {
         image_generation_model?: string;
         native_notebook_tools?: boolean;
         task_model_selection?: boolean;
+        code_mode?: boolean;
         speech_to_text_model?: string;
         speech_to_text_base_url?: string;
         speech_to_text_api_key?: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@kilocode/sdk",
-  "version": "7.7.3",
+  "version": "7.7.5",
   "type": "module",
   "license": "MIT",
   "scripts": {
@@ -41,6 +41,10 @@
     "./v2/types": {
       "import": "./dist/v2/gen/types.gen.js",
       "types": "./dist/v2/gen/types.gen.d.ts"
+    },
+    "./permission": {
+      "import": "./dist/kilocode/permission.js",
+      "types": "./dist/kilocode/permission.d.ts"
     }
   },
   "files": [