@swifty.js/swifty 0.0.33 → 0.0.35

package/dist/lib/agent-TC4HSVMS.js

@@ -0,0 +1,16 @@
+import {
+  Agent,
+  events_exports,
+  streaming_executor_exports
+} from "./chunk-S5VWPTME.js";
+import "./chunk-OJTISIYU.js";
+import "./chunk-BQFVUVLI.js";
+import "./chunk-HQSYRTER.js";
+import "./chunk-OLFXCZVH.js";
+import "./chunk-ZPIF7IJN.js";
+import "./chunk-MLKGABMK.js";
+export {
+  Agent,
+  events_exports as Events,
+  streaming_executor_exports as StreamingExecutor
+};

package/dist/lib/{anthropic-B33M2AVN.js → anthropic-FKIGL7NL.js}

@@ -5,11 +5,12 @@ import {
   markLastUserTailForCache,
   markToolsForCache,
   needsToolSearchBeta
-} from "./chunk-FODSMOWP.js";
-import "./chunk-XT67KGWE.js";
-import "./chunk-BCBD34D2.js";
-import "./chunk-3OFLDUAW.js";
-import "./chunk-3XCGUKGJ.js";
+} from "./chunk-6V7RW6HA.js";
+import "./chunk-BQFVUVLI.js";
+import "./chunk-HQSYRTER.js";
+import "./chunk-OLFXCZVH.js";
+import "./chunk-ZPIF7IJN.js";
+import "./chunk-MLKGABMK.js";
 export {
   AnthropicClient,
   buildAnthropicMessages,

package/dist/lib/bwrap-2OL7VPSO.js

@@ -0,0 +1,7 @@
+import {
+  BwrapSandbox
+} from "./chunk-YIWNQ7OA.js";
+import "./chunk-MLKGABMK.js";
+export {
+  BwrapSandbox
+};

package/dist/lib/{chunk-FODSMOWP.js → chunk-6V7RW6HA.js}

@@ -1,10 +1,6 @@
 import {
   normalizeToolResultContentBlock
-} from "./chunk-XT67KGWE.js";
-import {
-  MCP_TOOL_PREFIX,
-  isMcpToolLike
-} from "./chunk-BCBD34D2.js";
+} from "./chunk-BQFVUVLI.js";
 import {
   AuthenticationError,
   ContextTooLongError,
@@ -21,7 +17,11 @@ import {
   thinkingBudgetForLevel,
   toAnthropicThinkingEffort,
   toReasoningEffort
-} from "./chunk-3OFLDUAW.js";
+} from "./chunk-HQSYRTER.js";
+import {
+  MCP_TOOL_PREFIX,
+  isMcpToolLike
+} from "./chunk-OLFXCZVH.js";
 import {
   asErrorString,
   asRecord,
@@ -30,13 +30,37 @@ import {
   createChildLogger,
   isRecord,
   strArg
-} from "./chunk-3XCGUKGJ.js";
+} from "./chunk-ZPIF7IJN.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
 
 // src/llm/anthropic.ts
+var anthropic_exports = {};
+__export(anthropic_exports, {
+  AnthropicClient: () => AnthropicClient,
+  buildAnthropicMessages: () => buildAnthropicMessages,
+  fetchModelContextWindow: () => fetchModelContextWindow,
+  markLastUserTailForCache: () => markLastUserTailForCache,
+  markToolsForCache: () => markToolsForCache,
+  needsToolSearchBeta: () => needsToolSearchBeta
+});
 import Anthropic from "@anthropic-ai/sdk";
 import { safeParseAsync, z } from "zod";
 
 // src/mcp/strategy.ts
+var strategy_exports = {};
+__export(strategy_exports, {
+  CHARS_PER_TOKEN: () => CHARS_PER_TOKEN,
+  DEFAULT_EAGER_THRESHOLD_PERCENT: () => DEFAULT_EAGER_THRESHOLD_PERCENT,
+  NATIVE_TOOL_USE_BETA: () => NATIVE_TOOL_USE_BETA,
+  applyMode: () => applyMode,
+  decideAndApply: () => decideAndApply,
+  decideMode: () => decideMode,
+  estimateSchemaTokens: () => estimateSchemaTokens,
+  isOfficialAnthropicEndpoint: () => isOfficialAnthropicEndpoint,
+  measureSchemaChars: () => measureSchemaChars
+});
 var DEFAULT_EAGER_THRESHOLD_PERCENT = 10;
 var CHARS_PER_TOKEN = 2.5;
 var NATIVE_TOOL_USE_BETA = "advanced-tool-use-2025-11-20";
@@ -570,19 +594,13 @@ function classifyAnthropicError(err) {
 }
 
 export {
-  DEFAULT_EAGER_THRESHOLD_PERCENT,
-  CHARS_PER_TOKEN,
-  NATIVE_TOOL_USE_BETA,
-  isOfficialAnthropicEndpoint,
-  estimateSchemaTokens,
-  decideMode,
-  measureSchemaChars,
-  applyMode,
   decideAndApply,
+  strategy_exports,
   markToolsForCache,
   needsToolSearchBeta,
   fetchModelContextWindow,
   buildAnthropicMessages,
   AnthropicClient,
-  markLastUserTailForCache
+  markLastUserTailForCache,
+  anthropic_exports
 };

package/dist/lib/{chunk-TJLAJGG4.js → chunk-ALQHMYOZ.js}

@@ -11,7 +11,7 @@ import {
   getThinkingLevel,
   resolveAPIKey,
   toReasoningEffort
-} from "./chunk-3OFLDUAW.js";
+} from "./chunk-HQSYRTER.js";
 import {
   asRecord,
   asString,
@@ -19,9 +19,19 @@ import {
   createChildLogger,
   isRecord,
   strArg
-} from "./chunk-3XCGUKGJ.js";
+} from "./chunk-ZPIF7IJN.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
 
 // src/llm/openai.ts
+var openai_exports = {};
+__export(openai_exports, {
+  OpenAIClient: () => OpenAIClient,
+  OpenAICompatClient: () => OpenAICompatClient,
+  buildChatCompletionMessages: () => buildChatCompletionMessages,
+  buildOpenAIInput: () => buildOpenAIInput
+});
 import OpenAI from "openai";
 var log = createChildLogger({ module: "llm" });
 function computerActionArguments(action) {
@@ -842,5 +852,6 @@ export {
   OpenAIClient,
   buildOpenAIInput,
   OpenAICompatClient,
-  buildChatCompletionMessages
+  buildChatCompletionMessages,
+  openai_exports
 };

package/dist/lib/{chunk-XT67KGWE.js → chunk-BQFVUVLI.js}

@@ -1,4 +1,14 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
 // src/tools/types.ts
+var types_exports = {};
+__export(types_exports, {
+  SKIP_DIRS: () => SKIP_DIRS,
+  isToolResultContentBlock: () => isToolResultContentBlock,
+  normalizeToolResultContentBlock: () => normalizeToolResultContentBlock
+});
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -135,6 +145,6 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
 
 export {
   normalizeToolResultContentBlock,
-  isToolResultContentBlock,
-  SKIP_DIRS
+  SKIP_DIRS,
+  types_exports
 };

package/dist/lib/chunk-FFM2LB4C.js

@@ -0,0 +1,132 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/sandbox/sandbox-runtime.ts
+var sandbox_runtime_exports = {};
+__export(sandbox_runtime_exports, {
+  SandboxRuntimeSandbox: () => SandboxRuntimeSandbox,
+  createSandboxRuntimeConfig: () => createSandboxRuntimeConfig
+});
+import { isAbsolute, resolve } from "path";
+async function loadSandboxRuntime() {
+  return await import("@anthropic-ai/sandbox-runtime");
+}
+function resolvePaths(paths, cwd) {
+  return paths.map((path) => isAbsolute(path) ? path : resolve(cwd, path));
+}
+function createSandboxRuntimeConfig(config, cwd) {
+  return {
+    network: {
+      allowedDomains: [],
+      deniedDomains: config.networkEnabled ? [] : ["*"],
+      strictAllowlist: !config.networkEnabled
+    },
+    filesystem: {
+      denyRead: [],
+      allowWrite: resolvePaths(config.allowWrite, cwd),
+      denyWrite: resolvePaths(config.denyWrite, cwd),
+      allowGitConfig: false
+    }
+  };
+}
+var SandboxRuntimeSandbox = class {
+  implementation = "sandbox-runtime";
+  availabilityError;
+  availabilityPromise;
+  configKey;
+  initializationPromise;
+  runtimePromise;
+  available() {
+    return this.availabilityPromise ??= this.checkAvailability();
+  }
+  async prepare(command, config, context) {
+    if (!await this.available()) {
+      throw new Error(this.availabilityError ?? "sandbox runtime is unavailable");
+    }
+    const runtime = await this.loadRuntime();
+    const runtimeConfig = runtime.SandboxRuntimeConfigSchema.parse(
+      createSandboxRuntimeConfig(config, context.cwd)
+    );
+    const configKey = JSON.stringify(runtimeConfig);
+    if (this.initializationPromise) {
+      await this.initializationPromise;
+    }
+    if (this.configKey !== configKey || !runtime.SandboxManager.isSandboxingEnabled()) {
+      this.initializationPromise = (async () => {
+        if (runtime.SandboxManager.isSandboxingEnabled()) {
+          await runtime.SandboxManager.reset();
+        }
+        await runtime.SandboxManager.initialize(
+          runtimeConfig,
+          config.networkEnabled ? () => Promise.resolve(true) : void 0
+        );
+        this.configKey = configKey;
+      })();
+      try {
+        await this.initializationPromise;
+      } finally {
+        this.initializationPromise = void 0;
+      }
+    }
+    const commandId = context.commandId ?? command;
+    const prepared = await runtime.SandboxManager.wrapWithSandboxArgv(
+      command,
+      "/bin/bash",
+      void 0,
+      context.abortSignal,
+      context.cwd,
+      { commandId, commandText: command }
+    );
+    const [executable, ...args] = prepared.argv;
+    if (!executable) {
+      throw new Error("sandbox runtime returned an empty command");
+    }
+    return {
+      executable,
+      args,
+      env: prepared.env,
+      annotateStderr: (stderr) => runtime.SandboxManager.annotateStderrWithSandboxFailures(commandId, stderr),
+      cleanup: () => {
+        runtime.SandboxManager.cleanupAfterCommand();
+      }
+    };
+  }
+  async dispose() {
+    if (!this.runtimePromise) {
+      return;
+    }
+    await this.initializationPromise;
+    const runtime = await this.runtimePromise;
+    await runtime.SandboxManager.reset();
+    this.configKey = void 0;
+  }
+  async checkAvailability() {
+    try {
+      const runtime = await this.loadRuntime();
+      if (!runtime.SandboxManager.isSupportedPlatform()) {
+        this.availabilityError = "sandbox runtime does not support this platform";
+        return false;
+      }
+      const dependencies = await runtime.SandboxManager.checkDependenciesAsync();
+      if (dependencies.errors.length > 0) {
+        this.availabilityError = dependencies.errors.join("; ");
+        return false;
+      }
+      this.availabilityError = void 0;
+      return true;
+    } catch (error) {
+      this.availabilityError = error instanceof Error ? error.message : String(error);
+      return false;
+    }
+  }
+  loadRuntime() {
+    return this.runtimePromise ??= loadSandboxRuntime();
+  }
+};
+
+export {
+  createSandboxRuntimeConfig,
+  SandboxRuntimeSandbox,
+  sandbox_runtime_exports
+};

package/dist/lib/{chunk-VUD72RTY.js → chunk-FLKB4BK7.js}

@@ -1,14 +1,24 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
 // src/sandbox/seatbelt.ts
+var seatbelt_exports = {};
+__export(seatbelt_exports, {
+  SeatbeltSandbox: () => SeatbeltSandbox
+});
 import { existsSync, statSync } from "fs";
 var SANDBOX_EXEC_PATH = "/usr/bin/sandbox-exec";
 var SeatbeltSandbox = class {
+  implementation = "seatbelt";
   available() {
     return existsSync(SANDBOX_EXEC_PATH);
   }
-  wrap(command, config) {
-    const profile = buildProfile(config);
-    const escaped = command.replace(/'/g, "'\\''");
-    return `${SANDBOX_EXEC_PATH} -p '${profile}' bash -c '${escaped}'`;
+  prepare(command, config) {
+    return {
+      executable: SANDBOX_EXEC_PATH,
+      args: ["-p", buildProfile(config), "bash", "-c", command]
+    };
   }
 };
 function buildProfile(config) {
@@ -35,5 +45,6 @@ function buildProfile(config) {
 }
 
 export {
-  SeatbeltSandbox
+  SeatbeltSandbox,
+  seatbelt_exports
 };

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/{providers-UJEWP7C7.js → chunk-OJTISIYU.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.35";
+  }
+  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
 };