@swifty.js/swifty 0.0.33 → 0.0.36

package/dist/lib/{chunk-3OFLDUAW.js → chunk-HQSYRTER.js}

@@ -1,42 +1,40 @@
 import {
   createChildLogger
-} from "./chunk-3XCGUKGJ.js";
-
-// src/llm/errors.ts
-var LLMError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "LLMError";
-  }
-};
-var AuthenticationError = class extends LLMError {
-  constructor(message) {
-    super(message);
-    this.name = "AuthenticationError";
-  }
-};
-var RateLimitError = class extends LLMError {
-  retryAfter;
-  constructor(message, retryAfter) {
-    super(message);
-    this.name = "RateLimitError";
-    this.retryAfter = retryAfter;
-  }
-};
-var NetworkError = class extends LLMError {
-  constructor(message) {
-    super(message);
-    this.name = "NetworkError";
-  }
-};
-var ContextTooLongError = class extends LLMError {
-  constructor(message) {
-    super(message);
-    this.name = "ContextTooLongError";
-  }
-};
+} from "./chunk-ZPIF7IJN.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
 
-// src/config/config.ts
+// src/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  ConfigError: () => ConfigError,
+  DEFAULT_CONTEXT_WINDOW: () => DEFAULT_CONTEXT_WINDOW,
+  DEFAULT_MAX_OUTPUT_TOKENS: () => DEFAULT_MAX_OUTPUT_TOKENS,
+  DEFAULT_THINKING_LEVEL: () => DEFAULT_THINKING_LEVEL,
+  HookConfigSchema: () => HookConfigSchema,
+  MIN_THINKING_ANSWER_TOKENS: () => MIN_THINKING_ANSWER_TOKENS,
+  MIN_THINKING_BUDGET_TOKENS: () => MIN_THINKING_BUDGET_TOKENS,
+  ProviderConfigSchema: () => ProviderConfigSchema,
+  THINKING_BUDGETS: () => THINKING_BUDGETS,
+  THINKING_LEVELS: () => THINKING_LEVELS,
+  clampThinkingLevel: () => clampThinkingLevel,
+  forkEnabled: () => forkEnabled,
+  getContextWindow: () => getContextWindow,
+  getMaxOutputTokens: () => getMaxOutputTokens,
+  getSupportedThinkingLevels: () => getSupportedThinkingLevels,
+  getThinkingLevel: () => getThinkingLevel,
+  globalConfigPath: () => globalConfigPath,
+  isValidThinkingLevel: () => isValidThinkingLevel,
+  loadConfig: () => loadConfig,
+  loadProjectMcpServers: () => loadProjectMcpServers,
+  resolveAPIKey: () => resolveAPIKey,
+  thinkingBudgetForLevel: () => thinkingBudgetForLevel,
+  toAnthropicThinkingEffort: () => toAnthropicThinkingEffort,
+  toReasoningEffort: () => toReasoningEffort,
+  withProjectMcpServers: () => withProjectMcpServers,
+  withProviderDefaults: () => withProviderDefaults
+});
 import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
@@ -224,6 +222,7 @@ var HookConfigSchema = z.object({
 });
 var SandboxYamlConfigSchema = z.object({
   enabled: z.boolean().optional(),
+  backend: z.enum(["native", "sandbox-runtime"]).optional(),
   auto_allow: z.boolean().optional(),
   network_enabled: z.boolean().optional()
 });
@@ -304,6 +303,10 @@ function loadSingleFile(path) {
     const parsed2 = safeParse(SandboxYamlConfigSchema, raw.sandbox);
     if (parsed2.success) {
       sandbox = parsed2.data;
+    } else {
+      throw new ConfigError(
+        `Invalid sandbox configuration in ${path}: ${getParseErrorMessage(parsed2.error)}`
+      );
     }
   }
   if ("enable_coordinator_mode" in raw) {
@@ -483,6 +486,12 @@ function loadConfig(path, options = {}) {
 }
 
 // src/conversation/pairing.ts
+var pairing_exports = {};
+__export(pairing_exports, {
+  INTERRUPTED_TOOL_RESULT: () => INTERRUPTED_TOOL_RESULT,
+  REJECTED_TOOL_RESULT: () => REJECTED_TOOL_RESULT,
+  ensureToolPairing: () => ensureToolPairing
+});
 var INTERRUPTED_TOOL_RESULT = "Tool execution was interrupted. The tool may or may not have completed; verify before relying on its effects.";
 var REJECTED_TOOL_RESULT = "The user rejected this tool use. Nothing was changed (for file edits, the new content was NOT written).";
 function ensureToolPairing(messages) {
@@ -533,21 +542,55 @@ function ensureToolPairing(messages) {
   return out;
 }
 
+// src/llm/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  AuthenticationError: () => AuthenticationError,
+  ContextTooLongError: () => ContextTooLongError,
+  LLMError: () => LLMError,
+  NetworkError: () => NetworkError,
+  RateLimitError: () => RateLimitError
+});
+var LLMError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LLMError";
+  }
+};
+var AuthenticationError = class extends LLMError {
+  constructor(message) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends LLMError {
+  retryAfter;
+  constructor(message, retryAfter) {
+    super(message);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var NetworkError = class extends LLMError {
+  constructor(message) {
+    super(message);
+    this.name = "NetworkError";
+  }
+};
+var ContextTooLongError = class extends LLMError {
+  constructor(message) {
+    super(message);
+    this.name = "ContextTooLongError";
+  }
+};
+
 export {
-  LLMError,
-  AuthenticationError,
-  RateLimitError,
-  NetworkError,
-  ContextTooLongError,
-  ConfigError,
   globalConfigPath,
   THINKING_LEVELS,
   ProviderConfigSchema,
   DEFAULT_THINKING_LEVEL,
   DEFAULT_CONTEXT_WINDOW,
   DEFAULT_MAX_OUTPUT_TOKENS,
-  THINKING_BUDGETS,
-  MIN_THINKING_BUDGET_TOKENS,
   MIN_THINKING_ANSWER_TOKENS,
   isValidThinkingLevel,
   getThinkingLevel,
@@ -556,16 +599,20 @@ export {
   toAnthropicThinkingEffort,
   getSupportedThinkingLevels,
   clampThinkingLevel,
-  withProviderDefaults,
   getContextWindow,
   getMaxOutputTokens,
   resolveAPIKey,
-  HookConfigSchema,
   forkEnabled,
-  loadProjectMcpServers,
   withProjectMcpServers,
   loadConfig,
-  INTERRUPTED_TOOL_RESULT,
+  config_exports,
   REJECTED_TOOL_RESULT,
-  ensureToolPairing
+  ensureToolPairing,
+  pairing_exports,
+  LLMError,
+  AuthenticationError,
+  RateLimitError,
+  NetworkError,
+  ContextTooLongError,
+  errors_exports
 };

package/dist/lib/{chunk-LDWFI6MR.js → chunk-LRN4MOQ3.js}

@@ -1,4 +1,25 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/subagent/tool-filter.ts
+var tool_filter_exports = {};
+__export(tool_filter_exports, {
+  ASYNC_AGENT_ALLOWED_TOOLS: () => ASYNC_AGENT_ALLOWED_TOOLS,
+  CUSTOM_AGENT_DISALLOWED_TOOLS: () => CUSTOM_AGENT_DISALLOWED_TOOLS,
+  FORK_QUERY_SOURCE: () => FORK_QUERY_SOURCE,
+  MAIN_AGENT_ONLY_TOOLS: () => MAIN_AGENT_ONLY_TOOLS,
+  SUBAGENT_DISALLOWED_TOOLS: () => SUBAGENT_DISALLOWED_TOOLS,
+  TEAMMATE_DISALLOWED_TOOLS: () => TEAMMATE_DISALLOWED_TOOLS,
+  cloneRegistryForFork: () => cloneRegistryForFork,
+  filterToolsForAgent: () => filterToolsForAgent
+});
+
 // src/tools/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  ToolRegistry: () => ToolRegistry
+});
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
   discovered = /* @__PURE__ */ new Set();
@@ -157,6 +178,7 @@ var ASYNC_AGENT_ALLOWED_TOOLS = /* @__PURE__ */ new Set([
   "Grep",
   "Glob",
   "Bash",
+  "JavaScript",
   "PowerShell",
   "EditFile",
   "WriteFile",
@@ -230,6 +252,7 @@ function cloneRegistryForFork(registry) {
 
 export {
   ToolRegistry,
+  registry_exports,
   MAIN_AGENT_ONLY_TOOLS,
   SUBAGENT_DISALLOWED_TOOLS,
   TEAMMATE_DISALLOWED_TOOLS,
@@ -237,5 +260,6 @@ export {
   ASYNC_AGENT_ALLOWED_TOOLS,
   filterToolsForAgent,
   FORK_QUERY_SOURCE,
-  cloneRegistryForFork
+  cloneRegistryForFork,
+  tool_filter_exports
 };

package/dist/lib/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/lib/{chunk-BCBD34D2.js → chunk-OLFXCZVH.js}

@@ -3,9 +3,30 @@ import {
   asRecord,
   createChildLogger,
   strArg
-} from "./chunk-3XCGUKGJ.js";
+} from "./chunk-ZPIF7IJN.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/tools/mcp-call.ts
+var mcp_call_exports = {};
+__export(mcp_call_exports, {
+  McpCallTool: () => McpCallTool,
+  coerceBySchema: () => coerceBySchema,
+  isMcpToolLike: () => isMcpToolLike,
+  mcpCallPermissionContent: () => mcpCallPermissionContent
+});
 
 // src/mcp/tool-wrapper.ts
+var tool_wrapper_exports = {};
+__export(tool_wrapper_exports, {
+  MCPToolWrapper: () => MCPToolWrapper,
+  MCP_NAME_SEP: () => MCP_NAME_SEP,
+  MCP_TOOL_PREFIX: () => MCP_TOOL_PREFIX,
+  buildMcpToolName: () => buildMcpToolName,
+  mcpToolNamePrefix: () => mcpToolNamePrefix,
+  sanitizeSegment: () => sanitizeSegment
+});
 var log = createChildLogger({ module: "mcp" });
 var MCP_TOOL_PREFIX = "mcp__";
 var MCP_NAME_SEP = "__";
@@ -225,13 +246,10 @@ var McpCallTool = class {
 
 export {
   MCP_TOOL_PREFIX,
-  MCP_NAME_SEP,
-  sanitizeSegment,
-  mcpToolNamePrefix,
-  buildMcpToolName,
   MCPToolWrapper,
-  coerceBySchema,
+  tool_wrapper_exports,
   mcpCallPermissionContent,
   isMcpToolLike,
-  McpCallTool
+  McpCallTool,
+  mcp_call_exports
 };

package/dist/lib/{providers-UJEWP7C7.js → chunk-PJ7354ZG.js}

@@ -1,8 +1,13 @@
 import {
-  version
-} from "./chunk-GTHYQZRL.js";
+  __export
+} from "./chunk-MLKGABMK.js";
 
 // src/telemetry/providers.ts
+var providers_exports = {};
+__export(providers_exports, {
+  createTelemetryRuntime: () => createTelemetryRuntime,
+  parseExporterTypes: () => parseExporterTypes
+});
 import { LangfuseSpanProcessor } from "@langfuse/otel";
 import {
   setLangfuseTracerProvider,
@@ -27,6 +32,40 @@ import {
   ConsoleSpanExporter
 } from "@opentelemetry/sdk-trace-base";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+
+// src/version.ts
+var version_exports = {};
+__export(version_exports, {
+  version: () => version
+});
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { z } from "zod";
+var PackageJsonSchema = z.object({
+  version: z.string()
+});
+function resolveVersion() {
+  if (true) {
+    return "0.0.36";
+  }
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  for (const levels of ["..", "../.."]) {
+    const candidate = path.resolve(here, levels, "package.json");
+    try {
+      const raw = JSON.parse(readFileSync(candidate, "utf-8"));
+      const parsed = PackageJsonSchema.safeParse(raw);
+      if (parsed.success) {
+        return parsed.data.version;
+      }
+    } catch {
+    }
+  }
+  throw new Error("Could not resolve package version");
+}
+var version = resolveVersion();
+
+// src/telemetry/providers.ts
 var DEFAULT_EXPORT_INTERVAL_MS = 6e4;
 var SHUTDOWN_TIMEOUT_MS = 2e3;
 function parseExporterTypes(value) {
@@ -413,7 +452,11 @@ async function createTelemetryRuntime() {
   const logger = loggerProvider?.getLogger("@swifty.js/swifty", version) ?? null;
   return new ProviderRuntime(tracerProvider, loggerProvider, meterProvider, meter, logger, sentry);
 }
+
 export {
+  version,
+  version_exports,
+  parseExporterTypes,
   createTelemetryRuntime,
-  parseExporterTypes
+  providers_exports
 };

package/dist/lib/chunk-YIWNQ7OA.js

@@ -0,0 +1,47 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/sandbox/bwrap.ts
+var bwrap_exports = {};
+__export(bwrap_exports, {
+  BwrapSandbox: () => BwrapSandbox
+});
+import { execFileSync } from "child_process";
+var BwrapSandbox = class {
+  implementation = "bwrap";
+  detected;
+  available() {
+    if (this.detected !== void 0) {
+      return this.detected;
+    }
+    try {
+      execFileSync("which", ["bwrap"], { stdio: "ignore" });
+      this.detected = true;
+    } catch {
+      this.detected = false;
+    }
+    return this.detected;
+  }
+  prepare(command, config) {
+    const args = ["--unshare-user", "--unshare-pid"];
+    args.push("--ro-bind", "/", "/");
+    for (const path of config.allowWrite) {
+      args.push("--bind", path, path);
+    }
+    for (const path of config.denyWrite) {
+      args.push("--ro-bind", path, path);
+    }
+    if (!config.networkEnabled) {
+      args.push("--unshare-net");
+    }
+    args.push("--proc", "/proc");
+    args.push("--", "bash", "-c", command);
+    return { executable: "bwrap", args };
+  }
+};
+
+export {
+  BwrapSandbox,
+  bwrap_exports
+};