@openbox-ai/openbox-mastra-sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OpenBox Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,158 @@
+# OpenBox Mastra SDK
+
+`@openbox-ai/openbox-mastra-sdk` adds OpenBox governance, approvals, guardrails, and OpenTelemetry-backed operational telemetry to Mastra applications.
+
+Use it when you need to:
+
+- evaluate tools, workflow steps, workflows, and agents against OpenBox policy
+- enforce approval flows from OpenBox verdicts
+- apply input and output guardrails
+- attach HTTP, database, file, and traced-function telemetry to governed runs
+- install the integration once and keep future Mastra registrations governed
+
+## Requirements
+
+- Node.js `>=24.10.0`
+- `@mastra/core` `^1.8.0`
+- an OpenBox Core deployment reachable from the Mastra runtime
+- an ESM-capable runtime and build pipeline
+
+## Installation
+
+```bash
+npm install @openbox-ai/openbox-mastra-sdk @mastra/core
+```
+
+Required environment variables:
+
+```bash
+export OPENBOX_URL="https://your-openbox-core.example"
+export OPENBOX_API_KEY="obx_live_your_key"
+```
+
+Optional but commonly used:
+
+```bash
+export OPENBOX_GOVERNANCE_POLICY="fail_open"
+export OPENBOX_DEBUG="false"
+```
+
+## Quick Start
+
+```ts
+import { Mastra } from "@mastra/core/mastra";
+import {
+  getOpenBoxRuntime,
+  withOpenBox
+} from "@openbox-ai/openbox-mastra-sdk";
+
+const mastra = new Mastra({
+  agents: {
+    // your agents
+  },
+  tools: {
+    // your tools
+  },
+  workflows: {
+    // your workflows
+  }
+});
+
+const governedMastra = await withOpenBox(mastra, {
+  apiKey: process.env.OPENBOX_API_KEY,
+  apiUrl: process.env.OPENBOX_URL
+});
+
+process.on("SIGTERM", async () => {
+  await getOpenBoxRuntime(governedMastra)?.shutdown();
+});
+```
+
+`withOpenBox()` is the recommended production entrypoint. It:
+
+1. parses and validates SDK configuration
+2. validates the API key unless `validate: false` is set
+3. creates the OpenBox client and span processor
+4. installs process-wide telemetry
+5. wraps existing Mastra tools, workflows, and agents
+6. patches future `addTool()`, `addWorkflow()`, and `addAgent()` calls
+
+## Runtime Model
+
+The SDK emits three categories of OpenBox payloads:
+
+- boundary workflow events: `WorkflowStarted`, `WorkflowCompleted`, `WorkflowFailed`
+- boundary activity events: `ActivityStarted`, `ActivityCompleted`
+- signal events: `SignalReceived` for workflow resume, agent `user_input`, agent `resume`, and agent `agent_output`
+
+It also captures operational spans for:
+
+- HTTP requests
+- supported database libraries
+- file operations when file instrumentation is enabled
+- custom functions wrapped with `traced()`
+
+Important production behavior:
+
+- agent-only LLM activity is represented as telemetry spans, not as standalone business activities
+- agent prompts are emitted as `SignalReceived(user_input)`, not as tool activities
+- the SDK ignores its own OpenBox API URL during telemetry setup to avoid feedback loops
+
+## Configuration Highlights
+
+Most applications only need a small part of the config surface:
+
+| Option | Default | Use it to |
+| --- | --- | --- |
+| `apiUrl` | required | point the SDK at OpenBox Core |
+| `apiKey` | required | authenticate governance and approval calls |
+| `validate` | `true` | fail fast on invalid credentials or insecure URL setup |
+| `onApiError` | `"fail_open"` | decide whether OpenBox outages should halt execution |
+| `hitlEnabled` | `true` | enable approval suspension or polling flows |
+| `httpCapture` | `true` | attach text HTTP bodies and headers to governance-relevant telemetry |
+| `instrumentDatabases` | `true` | capture supported database activity |
+| `instrumentFileIo` | `false` | enable file operation telemetry when required |
+| `sendStartEvent` | `true` | emit `WorkflowStarted` |
+| `sendActivityStartEvent` | `true` | emit `ActivityStarted` |
+| `skipActivityTypes` | `["send_governance_event"]` | suppress selected activity types entirely |
+| `skipSignals` | empty | suppress selected signal names |
+| `maxEvaluatePayloadBytes` | `256000` | cap payload size before compact fallback logic applies |
+
+See [docs/configuration.md](./docs/configuration.md) for the complete surface.
+
+## Production Guidance
+
+- Keep `validate` enabled outside tests and local mocks.
+- Use HTTPS for all non-localhost OpenBox endpoints.
+- Decide explicitly between `fail_open` and `fail_closed` before deployment.
+- Treat hook-triggered telemetry as internal operational data unless your policy intentionally governs it.
+- Keep `instrumentFileIo` disabled until you have a concrete file-governance requirement.
+- Initialize telemetry once per process and shut it down on process exit.
+
+## Documentation
+
+- [docs/README.md](./docs/README.md): documentation index and reading order
+- [docs/installation.md](./docs/installation.md): installation, startup, and shutdown
+- [docs/configuration.md](./docs/configuration.md): configuration surface, env vars, and defaults
+- [docs/integration-patterns.md](./docs/integration-patterns.md): `withOpenBox()` and manual integration patterns
+- [docs/architecture.md](./docs/architecture.md): runtime architecture and data flow
+- [docs/event-model.md](./docs/event-model.md): event types, payload shape, signals, and activity semantics
+- [docs/telemetry.md](./docs/telemetry.md): HTTP, database, file, and traced-function capture
+- [docs/approvals-and-guardrails.md](./docs/approvals-and-guardrails.md): verdict enforcement, approvals, and guardrails
+- [docs/security-and-privacy.md](./docs/security-and-privacy.md): transport, capture boundaries, and hardening guidance
+- [docs/troubleshooting.md](./docs/troubleshooting.md): common failures and diagnostics
+- [docs/api-reference.md](./docs/api-reference.md): public API summary
+
+## Public API Summary
+
+Top-level exports include:
+
+- `withOpenBox()` and `getOpenBoxRuntime()`
+- `wrapTool()`, `wrapWorkflow()`, and `wrapAgent()`
+- `OpenBoxClient`
+- `parseOpenBoxConfig()` and `initializeOpenBox()`
+- `setupOpenBoxOpenTelemetry()` and `traced()`
+- `OpenBoxSpanProcessor`
+- verdict, guardrail, workflow event, and error types
+
+See [docs/api-reference.md](./docs/api-reference.md) for the full reference.

package/dist/client/index.d.ts

@@ -0,0 +1,4 @@
+export { ApprovalPollRequest, ApprovalPollResponse, OpenBoxApiErrorPolicy, OpenBoxClient, OpenBoxClientOptions } from './openbox-client.js';
+import '../types/governance-verdict-response.js';
+import '../types/guardrails.js';
+import '../types/verdict.js';

package/dist/client/index.js

@@ -0,0 +1,2 @@
+export * from "./openbox-client.js";
+//# sourceMappingURL=index.js.map

package/dist/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/index.ts"],"sourcesContent":["export * from \"./openbox-client.js\";\n"],"mappings":"AAAA,cAAc;","names":[]}

package/dist/client/openbox-client.d.ts

@@ -0,0 +1,42 @@
+import { GovernanceVerdictResponse } from '../types/governance-verdict-response.js';
+import '../types/guardrails.js';
+import '../types/verdict.js';
+
+type OpenBoxApiErrorPolicy = "fail_open" | "fail_closed";
+interface OpenBoxClientOptions {
+    apiKey: string;
+    apiUrl: string;
+    evaluateMaxRetries?: number | undefined;
+    evaluateRetryBaseDelayMs?: number | undefined;
+    fetch?: typeof fetch;
+    onApiError?: OpenBoxApiErrorPolicy | undefined;
+    timeoutSeconds?: number | undefined;
+}
+interface ApprovalPollRequest {
+    activityId: string;
+    runId: string;
+    workflowId: string;
+}
+interface ApprovalPollResponse {
+    action?: string | undefined;
+    approval_expiration_time?: string | null | undefined;
+    expired?: boolean | undefined;
+    reason?: string | undefined;
+    verdict?: string | undefined;
+    [key: string]: unknown;
+}
+declare class OpenBoxClient {
+    #private;
+    readonly apiKey: string;
+    readonly apiUrl: string;
+    readonly evaluateMaxRetries: number;
+    readonly evaluateRetryBaseDelayMs: number;
+    readonly onApiError: OpenBoxApiErrorPolicy;
+    readonly timeoutSeconds: number;
+    constructor({ apiKey, apiUrl, evaluateMaxRetries, evaluateRetryBaseDelayMs, fetch: customFetch, onApiError, timeoutSeconds }: OpenBoxClientOptions);
+    validateApiKey(): Promise<void>;
+    evaluate(payload: Record<string, unknown>): Promise<GovernanceVerdictResponse | null>;
+    pollApproval(payload: ApprovalPollRequest): Promise<ApprovalPollResponse | null>;
+}
+
+export { type ApprovalPollRequest, type ApprovalPollResponse, type OpenBoxApiErrorPolicy, OpenBoxClient, type OpenBoxClientOptions };

package/dist/client/openbox-client.js

@@ -0,0 +1,405 @@
+import {
+  GovernanceAPIError,
+  GovernanceVerdictResponse,
+  OpenBoxAuthError,
+  OpenBoxNetworkError
+} from "../types/index.js";
+const USER_AGENT = "OpenBox-SDK/1.0";
+class OpenBoxClient {
+  apiKey;
+  apiUrl;
+  evaluateMaxRetries;
+  evaluateRetryBaseDelayMs;
+  onApiError;
+  timeoutSeconds;
+  #fetch;
+  #debugEnabled;
+  constructor({
+    apiKey,
+    apiUrl,
+    evaluateMaxRetries = 0,
+    evaluateRetryBaseDelayMs = 150,
+    fetch: customFetch,
+    onApiError = "fail_open",
+    timeoutSeconds = 30
+  }) {
+    this.apiKey = apiKey;
+    this.apiUrl = apiUrl.replace(/\/+$/, "");
+    this.evaluateMaxRetries = Math.max(0, Math.floor(evaluateMaxRetries));
+    this.evaluateRetryBaseDelayMs = Math.max(0, Math.floor(evaluateRetryBaseDelayMs));
+    this.onApiError = onApiError;
+    this.timeoutSeconds = timeoutSeconds;
+    this.#fetch = customFetch ?? fetch;
+    this.#debugEnabled = isOpenBoxDebugEnabled();
+  }
+  async validateApiKey() {
+    try {
+      const response = await this.#fetch(
+        this.#buildUrl("/api/v1/auth/validate"),
+        {
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+            "User-Agent": USER_AGENT
+          },
+          method: "GET",
+          signal: AbortSignal.timeout(this.timeoutSeconds * 1e3)
+        }
+      );
+      if (response.status === 200) {
+        return;
+      }
+      if (response.status === 401 || response.status === 403) {
+        throw new OpenBoxAuthError(
+          "Invalid API key. Check your API key at dashboard.openbox.ai"
+        );
+      }
+      throw new OpenBoxNetworkError(
+        `Cannot reach OpenBox Core at ${this.apiUrl}: HTTP ${response.status}`
+      );
+    } catch (error) {
+      if (error instanceof OpenBoxAuthError || error instanceof OpenBoxNetworkError) {
+        throw error;
+      }
+      throw new OpenBoxNetworkError(
+        `Cannot reach OpenBox Core at ${this.apiUrl}: ${this.#errorMessage(error)}`
+      );
+    }
+  }
+  async evaluate(payload) {
+    const normalizedPayload = normalizeEvaluatePayload(payload);
+    return this.#withApiPolicy(
+      async () => this.#evaluateWithRetry(normalizedPayload)
+    );
+  }
+  async pollApproval(payload) {
+    try {
+      if (this.#debugEnabled) {
+        console.info("[openbox-sdk] approval.request", {
+          activity_id: payload.activityId,
+          run_id: payload.runId,
+          workflow_id: payload.workflowId
+        });
+      }
+      const response = await this.#fetch(
+        this.#buildUrl("/api/v1/governance/approval"),
+        {
+          body: JSON.stringify({
+            activity_id: payload.activityId,
+            run_id: payload.runId,
+            workflow_id: payload.workflowId
+          }),
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+            "User-Agent": USER_AGENT
+          },
+          method: "POST",
+          signal: AbortSignal.timeout(this.timeoutSeconds * 1e3)
+        }
+      );
+      if (response.status !== 200) {
+        const body = await response.text().catch(() => "");
+        if (this.#debugEnabled) {
+          console.error("[openbox-sdk] approval.response", {
+            reason: body,
+            status: response.status
+          });
+        }
+        return null;
+      }
+      const data = await response.json();
+      if (this.#debugEnabled) {
+        console.info("[openbox-sdk] approval.response", {
+          action: data.action,
+          status: response.status,
+          verdict: data.verdict
+        });
+      }
+      const expirationTime = data.approval_expiration_time;
+      if (typeof expirationTime === "string") {
+        const parsed = parseApprovalExpiration(expirationTime);
+        if (parsed && Date.now() > parsed.getTime()) {
+          return {
+            ...data,
+            expired: true
+          };
+        }
+      }
+      return data;
+    } catch {
+      return null;
+    }
+  }
+  #buildUrl(pathname) {
+    return `${this.apiUrl}${pathname}`;
+  }
+  async #evaluateWithRetry(payload) {
+    let attempt = 0;
+    while (true) {
+      try {
+        return await this.#evaluateOnce(payload);
+      } catch (error) {
+        if (attempt >= this.evaluateMaxRetries || !isRetryableEvaluateError(error)) {
+          throw error;
+        }
+        const waitMs = this.evaluateRetryBaseDelayMs * 2 ** attempt;
+        if (this.#debugEnabled) {
+          console.warn("[openbox-sdk] evaluate.retry", {
+            attempt: attempt + 1,
+            error: error instanceof Error ? error.message : String(error),
+            wait_ms: waitMs
+          });
+        }
+        attempt += 1;
+        if (waitMs > 0) {
+          await delay(waitMs);
+        }
+      }
+    }
+  }
+  async #evaluateOnce(payload) {
+    if (this.#debugEnabled) {
+      console.info("[openbox-sdk] evaluate.request", summarizeEvaluatePayload(payload));
+    }
+    const response = await this.#fetch(
+      this.#buildUrl("/api/v1/governance/evaluate"),
+      {
+        body: JSON.stringify(payload),
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json",
+          "User-Agent": USER_AGENT
+        },
+        method: "POST",
+        signal: AbortSignal.timeout(this.timeoutSeconds * 1e3)
+      }
+    );
+    if (response.status !== 200) {
+      const body = await response.text();
+      if (this.#debugEnabled) {
+        console.error("[openbox-sdk] evaluate.response", {
+          event_type: payload.event_type,
+          reason: body,
+          status: response.status
+        });
+      }
+      throw new GovernanceAPIError(
+        `HTTP ${response.status}: ${body}`
+      );
+    }
+    const parsed = await response.json();
+    if (this.#debugEnabled) {
+      const ageResult = parsed && typeof parsed === "object" && "age_result" in parsed ? parsed.age_result : void 0;
+      console.info("[openbox-sdk] evaluate.response", {
+        action: parsed.action,
+        age_fallback_used: ageResult && typeof ageResult === "object" ? ageResult.fallback_used : void 0,
+        age_goal_alignment_checked: ageResult && typeof ageResult === "object" ? ageResult.goal_alignment_checked : void 0,
+        age_goal_drifted: ageResult && typeof ageResult === "object" ? ageResult.goal_drifted : void 0,
+        event_type: payload.event_type,
+        status: response.status,
+        verdict: parsed.verdict
+      });
+    }
+    return GovernanceVerdictResponse.fromObject(parsed);
+  }
+  async #withApiPolicy(operation) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (this.onApiError === "fail_open") {
+        return null;
+      }
+      if (error instanceof GovernanceAPIError) {
+        throw error;
+      }
+      throw new GovernanceAPIError(this.#errorMessage(error));
+    }
+  }
+  #errorMessage(error) {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    return String(error);
+  }
+}
+function isOpenBoxDebugEnabled() {
+  const value = process.env.OPENBOX_DEBUG?.trim().toLowerCase();
+  return value === "1" || value === "true" || value === "yes";
+}
+function summarizeEvaluatePayload(payload) {
+  const spanSummary = summarizeSpans(payload.spans);
+  return {
+    activity_id: payload.activity_id,
+    activity_type: payload.activity_type,
+    event_type: payload.event_type,
+    has_activity_input: payload.activity_input !== void 0,
+    has_activity_output: payload.activity_output !== void 0,
+    has_error: payload.error !== void 0,
+    has_goal: typeof payload.goal === "string" && payload.goal.trim().length > 0,
+    has_signal_args: payload.signal_args !== void 0,
+    has_spans: spanSummary.hasSpans,
+    has_workflow_input: payload.workflow_input !== void 0,
+    has_workflow_output: payload.workflow_output !== void 0,
+    hook_stage: payload.hook_trigger === true ? spanSummary.latestSpanStage : void 0,
+    run_id: payload.run_id,
+    span_count: typeof payload.span_count === "number" ? payload.span_count : spanSummary.detectedSpanCount,
+    synthetic_model_usage_span: spanSummary.syntheticModelUsageSpan,
+    workflow_model_id: typeof payload.model_id === "string" ? payload.model_id : void 0,
+    workflow_model_provider: typeof payload.model_provider === "string" ? payload.model_provider : typeof payload.provider === "string" ? payload.provider : void 0,
+    workflow_id: payload.workflow_id,
+    workflow_type: payload.workflow_type
+  };
+}
+function normalizeEvaluatePayload(payload) {
+  const normalized = { ...payload };
+  const eventType = typeof normalized.event_type === "string" ? normalized.event_type : void 0;
+  const legacyHookSpan = extractLegacyHookSpanFromTrigger(normalized.hook_trigger);
+  const normalizedHookTrigger = normalizeHookTrigger(normalized.hook_trigger);
+  if (normalizedHookTrigger !== void 0) {
+    normalized.hook_trigger = normalizedHookTrigger;
+  }
+  if (eventType === "ActivityCompleted") {
+    const normalizedSpans = normalizeSpansField(normalized.spans) ?? (legacyHookSpan ? [legacyHookSpan] : void 0);
+    if (normalizedHookTrigger === true || legacyHookSpan !== void 0) {
+      normalized.hook_trigger = true;
+      normalized.spans = normalizedSpans ?? [];
+      normalized.span_count = normalized.spans.length;
+      return normalized;
+    }
+    delete normalized.spans;
+    delete normalized.hook_trigger;
+    normalized.span_count = 0;
+    return normalized;
+  }
+  if (eventType === "ActivityStarted") {
+    const normalizedSpans = normalizeSpansField(normalized.spans) ?? (legacyHookSpan ? [legacyHookSpan] : void 0);
+    if (normalizedSpans !== void 0) {
+      normalized.spans = normalizedSpans;
+      normalized.span_count = normalizedSpans.length;
+      return normalized;
+    }
+    if (normalized.hook_trigger === true) {
+      normalized.spans = [];
+      normalized.span_count = 0;
+    }
+  }
+  return normalized;
+}
+function normalizeHookTrigger(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return value !== 0;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on") {
+      return true;
+    }
+    if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "off" || normalized.length === 0) {
+      return false;
+    }
+  }
+  if (typeof value === "object") {
+    return value !== null;
+  }
+  return Boolean(value);
+}
+function extractLegacyHookSpanFromTrigger(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  const hasHookShape = typeof record.type === "string" || typeof record.hook_type === "string" || typeof record.stage === "string" || typeof record.method === "string" || typeof record.url === "string" || typeof record.http_method === "string" || typeof record.http_url === "string" || typeof record.db_operation === "string" || typeof record.db_statement === "string" || typeof record.file_operation === "string" || typeof record.file_path === "string" || typeof record.function === "string";
+  if (!hasHookShape) {
+    return void 0;
+  }
+  const normalized = {
+    ...record
+  };
+  if (typeof normalized.type === "string" && typeof normalized.hook_type !== "string") {
+    normalized.hook_type = normalized.type;
+  }
+  delete normalized.type;
+  return normalized;
+}
+function normalizeSpansField(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    return value.filter(
+      (span) => span !== null && typeof span === "object"
+    );
+  }
+  if (value !== null && typeof value === "object") {
+    return [value];
+  }
+  return [];
+}
+function summarizeSpans(spans) {
+  if (!Array.isArray(spans)) {
+    return {
+      detectedSpanCount: 0,
+      hasSpans: false,
+      latestSpanStage: void 0,
+      syntheticModelUsageSpan: false
+    };
+  }
+  const spanList = spans;
+  const latestSpan = spanList.length > 0 ? spanList[spanList.length - 1] : void 0;
+  const latestSpanStage = latestSpan && typeof latestSpan === "object" ? (() => {
+    const stage = latestSpan.stage;
+    return typeof stage === "string" ? stage : void 0;
+  })() : void 0;
+  return {
+    detectedSpanCount: spanList.length,
+    hasSpans: spanList.length > 0,
+    latestSpanStage,
+    syntheticModelUsageSpan: spanList.some((span) => {
+      if (!span || typeof span !== "object") {
+        return false;
+      }
+      return span.name === "openbox.synthetic.model_usage";
+    })
+  };
+}
+function isRetryableEvaluateError(error) {
+  if (error instanceof GovernanceAPIError) {
+    if (/HTTP\s(429|5\d\d)\b/i.test(error.message)) {
+      return true;
+    }
+    return /(context deadline exceeded|temporarily unavailable|timeout|timed out|connection reset|econnreset|etimedout|upstream connect error)/i.test(
+      error.message
+    );
+  }
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  if (error.name === "AbortError") {
+    return true;
+  }
+  return /(fetch failed|network|econnreset|etimedout|connection reset)/i.test(
+    error.message
+  );
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function parseApprovalExpiration(value) {
+  const normalized = value.replace(" ", "T").replace(/Z$/, "+00:00");
+  const withTimezone = /([+-]\d{2}:\d{2})$/.test(normalized) ? normalized : `${normalized}Z`;
+  const parsed = new Date(withTimezone);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+export {
+  OpenBoxClient
+};
+//# sourceMappingURL=openbox-client.js.map