@qvac/sdk 0.14.1 → 0.15.0

package/dist/utils/path-sanitize.js

@@ -9,36 +9,33 @@
  * Throws on null bytes (literal or URL-encoded).
  */
 export function sanitizePathComponent(component) {
-    if (component === "")
-        return "";
+    if (component === '')
+        return '';
     // Reject null bytes (literal and URL-encoded)
-    if (component.includes("\0") || component.includes("%00")) {
+    if (component.includes('\0') || component.includes('%00')) {
         throw new Error(`Path component contains null byte: ${component}`);
     }
     let sanitized = component;
     // Decode common URL-encoded traversal sequences
-    sanitized = sanitized
-        .replace(/%2e/gi, ".")
-        .replace(/%2f/gi, "/")
-        .replace(/%5c/gi, "\\");
+    sanitized = sanitized.replace(/%2e/gi, '.').replace(/%2f/gi, '/').replace(/%5c/gi, '\\');
     // Normalize backslashes to forward slashes
-    sanitized = sanitized.replace(/\\/g, "/");
+    sanitized = sanitized.replace(/\\/g, '/');
     // Strip Windows drive letter prefixes (C:/, D:/, etc.)
-    sanitized = sanitized.replace(/^[A-Za-z]:\//, "");
+    sanitized = sanitized.replace(/^[A-Za-z]:\//, '');
     // Strip leading slashes (absolute path prefixes)
-    sanitized = sanitized.replace(/^\/+/, "");
+    sanitized = sanitized.replace(/^\/+/, '');
     // Remove all ".." segments (start, middle, end) iteratively until stable
-    let prev = "";
+    let prev = '';
     while (prev !== sanitized) {
         prev = sanitized;
-        sanitized = sanitized.replace(/^\.\.\//g, "");
-        sanitized = sanitized.replace(/\/\.\.$/g, "");
-        sanitized = sanitized.replace(/\/\.\.\//g, "/");
-        if (sanitized === "..")
-            sanitized = "";
+        sanitized = sanitized.replace(/^\.\.\//g, '');
+        sanitized = sanitized.replace(/\/\.\.$/g, '');
+        sanitized = sanitized.replace(/\/\.\.\//g, '/');
+        if (sanitized === '..')
+            sanitized = '';
     }
     // Strip any remaining leading slashes produced by stripping
-    sanitized = sanitized.replace(/^\/+/, "");
+    sanitized = sanitized.replace(/^\/+/, '');
     return sanitized;
 }
 /**

package/dist/utils/tool-helpers.d.ts

@@ -1,5 +1,5 @@
-import type { z } from "zod";
-import { type Tool, type ToolCall, type ToolCallWithCall } from "../schemas/tools";
+import type { z } from 'zod';
+import { type Tool, type ToolCall, type ToolCallWithCall } from '../schemas/tools';
 type ZodObjectType = z.ZodObject<z.ZodRawShape>;
 export type ToolHandler = (args: Record<string, unknown>) => Promise<unknown>;
 export type ToolInput<T extends ZodObjectType = ZodObjectType> = {

package/dist/utils/tool-helpers.js

@@ -1,45 +1,44 @@
-import { toolSchema, } from "../schemas/tools.js";
-import { InvalidToolsArrayError, InvalidToolSchemaError, } from "./errors-client.js";
+import { toolSchema } from '../schemas/tools.js';
+import { InvalidToolsArrayError, InvalidToolSchemaError } from './errors-client.js';
 function zodTypeToJsonSchemaType(type) {
     switch (type) {
-        case "string":
-            return "string";
-        case "number":
-            return "number";
-        case "boolean":
-            return "boolean";
-        case "object":
-            return "object";
-        case "array":
-            return "array";
-        case "optional":
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'object':
+            return 'object';
+        case 'array':
+            return 'array';
+        case 'optional':
         default:
-            return "string";
+            return 'string';
     }
 }
 export function convertToolInput(input) {
     const zodSchema = input.parameters;
     // Try both shape and def.shape for Zod v4 compatibility
-    const shape = zodSchema.shape ||
-        (typeof zodSchema.def?.shape === "object" ? zodSchema.def.shape : {});
+    const shape = zodSchema.shape || (typeof zodSchema.def?.shape === 'object' ? zodSchema.def.shape : {});
     const properties = {};
     const required = [];
     for (const [key, value] of Object.entries(shape)) {
         const field = value;
-        const fieldType = field.type || field.def?.type || "string";
-        const isOptional = fieldType === "optional";
-        let actualType = isOptional ? "string" : fieldType;
+        const fieldType = field.type || field.def?.type || 'string';
+        const isOptional = fieldType === 'optional';
+        let actualType = isOptional ? 'string' : fieldType;
         let actualDescription = field.description;
         if (isOptional && field.def?.innerType) {
             const innerType = field.def.innerType;
-            actualType = innerType.type || innerType.def?.type || "string";
+            actualType = innerType.type || innerType.def?.type || 'string';
             // Get description from inner type if not on wrapper
             if (!actualDescription && innerType.description) {
                 actualDescription = innerType.description;
             }
         }
         properties[key] = {
-            type: zodTypeToJsonSchemaType(actualType),
+            type: zodTypeToJsonSchemaType(actualType)
         };
         if (actualDescription) {
             properties[key].description = actualDescription;
@@ -52,14 +51,14 @@ export function convertToolInput(input) {
         }
     }
     const tool = {
-        type: "function",
+        type: 'function',
         name: input.name,
         description: input.description,
         parameters: {
-            type: "object",
+            type: 'object',
             properties,
-            required: required.length > 0 ? required : undefined,
-        },
+            required: required.length > 0 ? required : undefined
+        }
     };
     return toolSchema.parse(tool);
 }
@@ -104,7 +103,7 @@ export function attachHandlersToToolCalls(toolCalls, handlers) {
         if (handler) {
             return {
                 ...toolCall,
-                invoke: async () => await handler(toolCall.arguments),
+                invoke: async () => await handler(toolCall.arguments)
             };
         }
         return toolCall;

package/dist/utils/withTimeout.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Distinguishes a legitimate per-call timeout from a transport failure (e.g.
+ * a worker crash) for callers racing this against other rejection sources.
+ */
+export declare class OperationTimeoutError extends Error {
+    constructor(timeoutMs: number);
+}
 /**
  * Wraps a promise with an optional timeout
  * If no timeout is provided, returns the original promise unchanged

package/dist/utils/withTimeout.js

@@ -1,10 +1,20 @@
+/**
+ * Distinguishes a legitimate per-call timeout from a transport failure (e.g.
+ * a worker crash) for callers racing this against other rejection sources.
+ */
+export class OperationTimeoutError extends Error {
+    constructor(timeoutMs) {
+        super(`Operation timeout after ${timeoutMs}ms`);
+        this.name = 'OperationTimeoutError';
+    }
+}
 /**
  * Creates a timeout promise that rejects after the specified duration
  */
 function createTimeoutPromise(timeoutMs) {
     return new Promise((_, reject) => {
         setTimeout(() => {
-            reject(new Error(`Operation timeout after ${timeoutMs}ms`));
+            reject(new OperationTimeoutError(timeoutMs));
         }, timeoutMs);
     });
 }

package/dist/utils/zod-error.d.ts

@@ -1,3 +1,3 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare function formatZodError(error: z.ZodError): string;
 //# sourceMappingURL=zod-error.d.ts.map

package/dist/utils/zod-error.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export function formatZodError(error) {
     return z.prettifyError(error);
 }