@mettlelabs/mettle 0.0.0-beta.2-linux-arm64 → 0.0.0-beta.2

package/harness/chunk-fjx29qvp.mjs

@@ -1,50 +0,0 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM2 = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  if (mod && typeof mod === "object" || typeof mod === "function") {
-    for (let key of __getOwnPropNames(mod))
-      if (!__hasOwnProp.call(to, key))
-        __defProp(to, key, {
-          get: __accessProp.bind(mod, key),
-          enumerable: true
-        });
-  }
-  if (canCache)
-    cache.set(mod, to);
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-export { __toESM2, __commonJS, __export, __require };

package/harness/chunk-gryka6kg.mjs

@@ -1,39 +0,0 @@
-import {
-  MastraError
-} from "./chunk-v66qvpnb.mjs";
-
-// node_modules/.bun/@mastra+core@1.71.0+95d98e20cbc6e6e1/node_modules/@mastra/core/dist/gateway-helpers-Dh-2ojNA.js
-function getCapabilityFileName(provider) {
-  return `${encodeURIComponent(provider)}.json`;
-}
-function getGatewayId(gateway) {
-  return gateway.getId?.() ?? gateway.id;
-}
-function shouldEnableGateway(gateway) {
-  return gateway.shouldEnable?.() ?? true;
-}
-function hasAuthCredentials(auth) {
-  return Boolean(auth?.apiKey || auth?.bearerToken || auth?.headers && Object.keys(auth.headers).length > 0);
-}
-function findGatewayForModel(gatewayId, gateways) {
-  const prefixedGateway = gateways.find((g) => {
-    const id = getGatewayId(g);
-    return id !== "models.dev" && (id === gatewayId || gatewayId.startsWith(`${id}/`));
-  });
-  if (prefixedGateway)
-    return prefixedGateway;
-  const claimingGateway = gateways.find((g) => getGatewayId(g) !== "models.dev" && g.handlesModel?.(gatewayId) === true);
-  if (claimingGateway)
-    return claimingGateway;
-  const modelsDevGateway = gateways.find((g) => getGatewayId(g) === "models.dev");
-  if (modelsDevGateway)
-    return modelsDevGateway;
-  throw new MastraError({
-    id: "MODEL_ROUTER_NO_GATEWAY_FOUND",
-    category: "USER",
-    domain: "MODEL_ROUTER",
-    text: `No Mastra model router gateway found for model id ${gatewayId}`
-  });
-}
-
-export { getCapabilityFileName, getGatewayId, shouldEnableGateway, hasAuthCredentials, findGatewayForModel };

package/harness/chunk-h1td5kq9.mjs

@@ -1,422 +0,0 @@
-import {
-  MAX_LABEL,
-  MAX_PREVIEW_LINES,
-  MAX_PREVIEW_LINE,
-  HarnessError,
-  canonicalJson,
-  digest,
-  captureEvidence,
-  RUNTIME_VERSION
-} from "./chunk-rd80vvc5.mjs";
-import {
-  PROBE_TOOL,
-  SANDBOX_TOOLS,
-  PostgresJournal
-} from "./chunk-c7dx5mdd.mjs";
-import {
-  dockerJson,
-  SandboxWorker
-} from "./chunk-9dg1btk1.mjs";
-
-// apps/harness/src/execution/tool-executor.ts
-import { setTimeout as sleep } from "node:timers/promises";
-var APPROVAL_TTL_MS = 600000;
-var INTERRUPTED = "The operator interrupted this call while it ran; its outcome is unknown.";
-var SETTLED_FAILURES = new Set([
-  "tool_denied",
-  "work_denied",
-  "coverage_denied",
-  "approval_denied",
-  "approval_expired",
-  "invalid_artifact",
-  "sandbox_policy",
-  "sandbox_identity",
-  "sandbox_probe_failed",
-  "sandbox_output",
-  "sandbox_missing",
-  "sandbox_timeout",
-  "sandbox_unavailable",
-  "sandbox_image",
-  "candidate_denied",
-  "candidate_conflict",
-  "repository_bound",
-  "source_busy",
-  "source_unavailable",
-  "source_encoding",
-  "scanner_denied",
-  "web_denied",
-  "sandbox_task_failed",
-  "sandbox_output_limit",
-  "tool_interrupted"
-]);
-function settledFailure(error) {
-  return error instanceof HarnessError && SETTLED_FAILURES.has(error.code);
-}
-
-class ToolExecutor {
-  journal;
-  lease;
-  signal;
-  registry;
-  hooks;
-  constructor(journal, lease, signal, registry, hooks = {}) {
-    this.journal = journal;
-    this.lease = lease;
-    this.signal = signal;
-    this.registry = registry;
-    this.hooks = hooks;
-  }
-  async execute(callId, name, input, turn) {
-    if (this.signal.aborted)
-      throw new HarnessError("stop_requested", "Execution cancelled before admission.");
-    if (!callId)
-      throw new HarnessError("tool_denied", "A finalized tool call identity is required.");
-    let args;
-    let bytes;
-    try {
-      bytes = canonicalJson(input);
-      if (Buffer.byteLength(bytes, "utf8") > 65536)
-        throw new Error("Input limit exceeded.");
-      args = JSON.parse(bytes);
-    } catch {
-      throw new HarnessError("tool_denied", "Tool arguments must be bounded JSON.");
-    }
-    const tool = this.registry.admit(name, args, bytes);
-    const summary = tool.summarizeArgs(args).slice(0, 512);
-    const cachedRef = await this.journal.prepareAction(this.lease, callId, tool.name, args, {
-      label: tool.label(args).slice(0, MAX_LABEL),
-      summary,
-      quiet: tool.quiet?.(args) === true
-    }, tool.idempotent === true);
-    if (cachedRef)
-      return this.cached(cachedRef, tool);
-    if (tool.unavailableReason) {
-      await this.journal.failAction(this.lease, callId, tool.unavailableReason, "tool_denied");
-      throw new HarnessError("tool_denied", tool.unavailableReason);
-    }
-    const approval = await this.requested(callId, tool, args, summary);
-    await this.hooks.at?.("after-intent");
-    if (this.signal.aborted)
-      throw new HarnessError("stop_requested", "Execution cancelled before approval.");
-    if (approval)
-      await this.decided(callId, approval);
-    if (this.hooks.delayBeforeDispatchMs) {
-      try {
-        await sleep(this.hooks.delayBeforeDispatchMs, undefined, {
-          signal: this.signal
-        });
-      } catch {
-        throw new HarnessError("stop_requested", "Fixture wait cancelled before dispatch.");
-      }
-    }
-    if (this.signal.aborted)
-      throw new HarnessError("stop_requested", "Execution cancelled before dispatch.");
-    try {
-      await this.journal.dispatchAction(this.lease, callId);
-    } catch (error) {
-      if (error instanceof HarnessError && error.code === "tool_denied")
-        await this.journal.failAction(this.lease, callId, error.message, error.code);
-      throw error;
-    }
-    await this.hooks.at?.("after-dispatch");
-    let ref;
-    try {
-      const output = await tool.execute(args, turn ? AbortSignal.any([this.signal, turn]) : this.signal, callId);
-      await this.hooks.at?.("after-effect");
-      const result = tool.outputSchema.safeParse(output);
-      if (!result.success)
-        throw new HarnessError("invalid_artifact", "Tool output does not match its registered schema.");
-      const captured = captureEvidence(result.data);
-      const admitted = tool.outputSchema.safeParse(captured.value);
-      if (!admitted.success || canonicalJson(admitted.data) !== captured.bytes)
-        throw new HarnessError("invalid_artifact", "Redacted output is incompatible with the registered tool schema.");
-      const told = tool.summarizeResult(captured.value, args);
-      ref = await this.journal.completeAction(this.lease, callId, {
-        value: captured.value,
-        summary: told.summary.slice(0, 512),
-        ...told.rejected ? { rejected: true } : {},
-        ...told.preview?.length ? {
-          preview: told.preview.slice(0, MAX_PREVIEW_LINES).map((line) => line.slice(0, MAX_PREVIEW_LINE))
-        } : {}
-      });
-    } catch (error) {
-      if (turn?.aborted && !this.signal.aborted && !(error instanceof HarnessError && error.code === "lease_lost")) {
-        await this.journal.failAction(this.lease, callId, INTERRUPTED, "tool_interrupted", false);
-        throw new HarnessError("tool_interrupted", INTERRUPTED);
-      }
-      await this.settle(callId, error);
-      throw error;
-    }
-    await this.hooks.at?.("after-result");
-    return (await this.journal.artifact(this.lease.runId, ref)).bytes;
-  }
-  async requested(callId, tool, args, summary) {
-    const permission = tool.permission?.(args) ?? "local";
-    if (permission === "local")
-      return;
-    return this.journal.requestApproval(this.lease, callId, {
-      permission,
-      action: (tool.approval?.action ?? `${tool.name} ${summary}`).slice(0, 512),
-      detail: tool.approval?.detail ?? `${permission} against the live target; the effect may persist and the agent cannot undo it.`,
-      why: tool.approval?.why ?? `The ${permission} permission reaches outside the agent's sandbox, so an operator must authorize it before the call runs.`,
-      cleanup: tool.approval?.cleanup ?? "No automated rollback; an operator reverses any persisted effect manually if the call must be undone."
-    }, this.hooks.approvalTtlMs ?? APPROVAL_TTL_MS);
-  }
-  async decided(callId, approval) {
-    const current = await this.journal.approvalState(this.lease, approval.approvalId);
-    if (current.decision === null)
-      throw new HarnessError("approval_pending", "Execution is suspended until the recorded approval is decided or expires.");
-    if (current.decision === "allow")
-      return;
-    const error = current.decision === "deny" ? new HarnessError("approval_denied", `The operator denied ${current.permission} for this action.`) : new HarnessError("approval_expired", `The ${current.permission} approval expired before a decision.`);
-    await this.journal.failAction(this.lease, callId, error.message, error.code);
-    throw error;
-  }
-  async settle(callId, error) {
-    if (!(error instanceof HarnessError) || !SETTLED_FAILURES.has(error.code))
-      return;
-    await this.journal.failAction(this.lease, callId, error.message, error.code).catch(() => {
-      return;
-    });
-  }
-  async cached(ref, tool) {
-    const artifact = await this.journal.artifact(this.lease.runId, ref);
-    try {
-      if (!tool.outputSchema.safeParse(JSON.parse(artifact.bytes)).success)
-        throw new Error("Invalid result.");
-    } catch {
-      throw new HarnessError("invalid_artifact", "Stored tool output does not match its registered schema.");
-    }
-    return artifact.bytes;
-  }
-}
-
-// apps/harness/src/storage/sandbox-journal.ts
-import { randomUUID } from "node:crypto";
-class SandboxProbeJournal extends PostgresJournal {
-  get runtimeVersion() {
-    return `${RUNTIME_VERSION}/sandbox-probe-v1`;
-  }
-}
-
-class SandboxJournal {
-  journal;
-  lease;
-  constructor(journal, lease) {
-    this.journal = journal;
-    this.lease = lease;
-  }
-  async reserve(callId, workerId, image, policyDigest, binding = { tool: PROBE_TOOL, args: {} }, page) {
-    if (!SANDBOX_TOOLS.includes(binding.tool) || binding.tool === PROBE_TOOL && digest(binding.args) !== digest({}))
-      throw new HarnessError("sandbox_denied", "Only an approved isolated observation or fixed probe may reserve a sandbox.");
-    return this.journal.fenced(this.lease, async ({ client }) => {
-      const action = await client.query("SELECT 1 FROM harness_mastra.actions WHERE run_id=$1 AND call_id=$2 AND tool=$4 AND args_digest=$3 AND state='dispatched'", [this.lease.runId, callId, digest(binding.args), binding.tool]);
-      if (!action.rowCount)
-        throw new HarnessError("sandbox_denied", "A sandbox requires the exact committed observation dispatch.");
-      if (page) {
-        const available = await client.query("SELECT count(*)::int AS count,clock_timestamp()<$2::timestamptz AS active FROM harness_mastra.browser_pages WHERE run_id=$1 AND NOT closed", [this.lease.runId, page.expiresAt]);
-        if (binding.tool !== "web_browse" || page.operation !== "open" || available.rows[0].count >= 4 || !available.rows[0].active)
-          throw new HarnessError("browser_page_denied", "A live page requires an open operation, active grant and fewer than four retained pages.");
-      }
-      const record = {
-        runId: this.lease.runId,
-        callId,
-        epoch: this.lease.epoch,
-        workerId,
-        name: `mettle-${binding.tool.replace(/^sandbox_/, "")}-${randomUUID()}`,
-        image,
-        policyDigest,
-        containerId: null,
-        state: "reserved"
-      };
-      const inserted = await client.query("INSERT INTO harness_mastra.sandboxes(run_id,call_id,epoch,worker_id,name,image,policy_digest,state) VALUES ($1,$2,$3,$4,$5,$6,$7,'reserved') ON CONFLICT DO NOTHING", [
-        record.runId,
-        callId,
-        record.epoch,
-        workerId,
-        record.name,
-        image,
-        policyDigest
-      ]);
-      if (!inserted.rowCount)
-        throw new HarnessError("uncertain_execution", "A prior sandbox reservation cannot be executed again.");
-      if (page)
-        await client.query("INSERT INTO harness_mastra.browser_pages(run_id,page_id,sandbox_call,owner_call,child_id,identity_id,binding_digest,epoch,expires_at) VALUES($1,$2,$3,$3,$4,$5,$6,$7,LEAST($8::timestamptz,clock_timestamp()+interval '10 minutes'))", [
-          record.runId,
-          page.id,
-          callId,
-          this.lease.child?.id ?? null,
-          page.identity,
-          page.digest,
-          this.lease.epoch,
-          page.expiresAt
-        ]);
-      return record;
-    });
-  }
-  async acquirePage(callId, args, page) {
-    return this.journal.fenced(this.lease, async ({ client }) => {
-      const result = await client.query(`SELECT s.run_id AS "runId",s.call_id AS "callId",s.epoch,s.worker_id AS "workerId",s.name,s.image,s.policy_digest AS "policyDigest",s.container_id AS "containerId",s.state
-         FROM harness_mastra.browser_pages p JOIN harness_mastra.sandboxes s ON s.run_id=p.run_id AND s.call_id=p.sandbox_call
-         JOIN harness_mastra.actions a ON a.run_id=p.run_id AND a.call_id=$3
-         WHERE p.run_id=$1 AND p.page_id=$2 AND NOT p.closed AND p.owner_call IS NULL AND p.epoch=$4 AND p.child_id IS NOT DISTINCT FROM $5 AND p.identity_id=$6 AND p.binding_digest=$7 AND clock_timestamp()<p.expires_at
-         AND s.state='running' AND a.tool='web_browse' AND a.state='dispatched' AND a.args_digest=$8 AND a.child_id IS NOT DISTINCT FROM $5 FOR UPDATE OF p`, [
-        this.lease.runId,
-        page.id,
-        callId,
-        this.lease.epoch,
-        this.lease.child?.id ?? null,
-        page.identity,
-        page.digest,
-        digest(args)
-      ]);
-      if (page.operation === "open" || result.rowCount !== 1)
-        throw new HarnessError("browser_page_lost", "The page is absent, busy, expired, closed, or belongs to another identity, child, grant or worker epoch. Open a new page; previous actions are never replayed.");
-      await client.query("UPDATE harness_mastra.browser_pages SET owner_call=$3 WHERE run_id=$1 AND page_id=$2", [this.lease.runId, page.id, callId]);
-      return result.rows[0];
-    });
-  }
-  async suspendPages() {
-    await this.journal.fenced(this.lease, async ({ client }) => {
-      await client.query("UPDATE harness_mastra.browser_pages SET suspended_owner=$3 WHERE run_id=$1 AND epoch=$2 AND NOT closed AND owner_call IS NULL AND EXISTS (SELECT 1 FROM harness_mastra.approvals approval JOIN harness_mastra.actions action ON action.run_id=approval.run_id AND action.call_id=approval.call_id WHERE approval.run_id=$1 AND action.state='prepared')", [this.lease.runId, this.lease.epoch, this.lease.owner]);
-    }, "settlement");
-  }
-  async resumePages(previous) {
-    if (previous.runId !== this.lease.runId || previous.epoch + 1 !== this.lease.epoch)
-      throw new HarnessError("browser_page_lost", "Only the next owner can resume an approval suspension.");
-    await this.journal.fenced(this.lease, async ({ client }) => {
-      await client.query("UPDATE harness_mastra.browser_pages SET epoch=$4,suspended_owner=NULL WHERE run_id=$1 AND epoch=$2 AND suspended_owner=$3 AND NOT closed AND owner_call IS NULL AND clock_timestamp()<expires_at", [this.lease.runId, previous.epoch, previous.owner, this.lease.epoch]);
-    }, "settlement");
-  }
-  async releasePage(record, callId) {
-    await this.journal.fenced(this.lease, async ({ client }) => {
-      await this.assertState(record, "running", client);
-      const result = await client.query("UPDATE harness_mastra.browser_pages SET owner_call=NULL WHERE run_id=$1 AND sandbox_call=$2 AND owner_call=$3 AND epoch=$4 AND NOT closed", [this.lease.runId, record.callId, callId, this.lease.epoch]);
-      if (result.rowCount !== 1)
-        throw new HarnessError("browser_page_lost", "A different action owns this page.");
-    });
-  }
-  async pages() {
-    const retained = await this.journal.fenced(this.lease, async ({ client }) => {
-      const result = await client.query("SELECT sandbox_call FROM harness_mastra.browser_pages WHERE run_id=$1 AND NOT closed AND ($2::uuid IS NULL OR child_id=$2)", [this.lease.runId, this.lease.child?.id ?? null]);
-      return new Set(result.rows.map((row) => row.sandbox_call));
-    }, "settlement");
-    return (await this.pending()).filter((record) => retained.has(record.callId));
-  }
-  async provision(record, operation) {
-    await this.journal.fenced(this.lease, async ({ client }) => {
-      await this.assertState(record, "reserved", client);
-      const containerId = await operation();
-      await this.transition(record, "reserved", "created", containerId, client);
-    });
-  }
-  async start(record, operation) {
-    await this.journal.fenced(this.lease, async ({ client }) => {
-      await this.assertState(record, "created", client);
-      await operation();
-      await this.transition(record, "created", "running", record.containerId, client);
-    });
-  }
-  async transition(record, from, to, containerId, client) {
-    const result = await client.query("UPDATE harness_mastra.sandboxes SET state=$5,container_id=$6 WHERE run_id=$1 AND call_id=$2 AND epoch=$3 AND name=$4 AND state=$7", [
-      this.lease.runId,
-      record.callId,
-      this.lease.epoch,
-      record.name,
-      to,
-      containerId,
-      from
-    ]);
-    if (result.rowCount !== 1)
-      throw new HarnessError("sandbox_denied", "Sandbox ownership or lifecycle no longer permits this operation.");
-    record.containerId = containerId;
-    record.state = to;
-  }
-  async assertTaskRunning(record) {
-    await this.journal.fenced(this.lease, async ({ client }) => {
-      await this.assertState(record, "running", client);
-    });
-  }
-  async assertState(record, state, client) {
-    const result = await client.query("SELECT 1 FROM harness_mastra.sandboxes s WHERE run_id=$1 AND call_id=$2 AND epoch=$3 AND name=$4 AND state=$5 AND (epoch=$6 OR (state='running' AND EXISTS (SELECT 1 FROM harness_mastra.browser_pages p WHERE p.run_id=s.run_id AND p.sandbox_call=s.call_id AND p.epoch=$6 AND NOT p.closed AND p.owner_call IS NOT NULL)))", [
-      this.lease.runId,
-      record.callId,
-      record.epoch,
-      record.name,
-      state,
-      this.lease.epoch
-    ]);
-    if (record.runId !== this.lease.runId || result.rowCount !== 1)
-      throw new HarnessError("sandbox_denied", "Sandbox ownership or lifecycle no longer permits this operation.");
-  }
-  async removed(record) {
-    await this.journal.fenced(this.lease, async ({ client }) => {
-      const result = await client.query("UPDATE harness_mastra.sandboxes SET state='removed',removed_at=clock_timestamp() WHERE run_id=$1 AND call_id=$2 AND name=$3 AND worker_id=$4", [this.lease.runId, record.callId, record.name, record.workerId]);
-      if (record.runId !== this.lease.runId || !result.rowCount)
-        throw new HarnessError("sandbox_denied", "Cleanup receipt does not belong to this run.");
-      await client.query("UPDATE harness_mastra.browser_pages SET closed=true,owner_call=NULL WHERE run_id=$1 AND sandbox_call=$2", [this.lease.runId, record.callId]);
-      record.state = "removed";
-    }, "settlement");
-  }
-  async pending() {
-    return this.journal.fenced(this.lease, async ({ client }) => {
-      const result = await client.query(`SELECT run_id AS "runId",call_id AS "callId",epoch,worker_id AS "workerId",name,image,policy_digest AS "policyDigest",container_id AS "containerId",state FROM harness_mastra.sandboxes WHERE run_id=$1 AND state!='removed' ORDER BY name`, [this.lease.runId]);
-      return result.rows;
-    }, "settlement");
-  }
-  async markCleanupAttempt() {
-    await this.journal.fenced(this.lease, async ({ client }) => {
-      await client.query("UPDATE harness_mastra.sandboxes SET cleanup_attempted_at=clock_timestamp() WHERE run_id=$1 AND state!='removed'", [this.lease.runId]);
-    }, "settlement");
-  }
-}
-
-// apps/harness/src/sandbox/reaper.ts
-async function reapSandboxes(config, engine, journal, signal, runId, journalForRun) {
-  const info = dockerJson(await engine.call("GET", "/info"));
-  if (typeof info?.ID !== "string" || !info.ID)
-    throw new HarnessError("sandbox_unavailable", "The original engine identity is required.");
-  const candidates = runId ? [runId] : await journal.orphanedRuns(info.ID);
-  const outcomes = [];
-  for (const runId of candidates) {
-    if (signal.aborted)
-      break;
-    let lease;
-    let selected = journal;
-    try {
-      selected = journalForRun ? await journalForRun(runId) : journal;
-      lease = await selected.acquire(runId, 30000);
-      const lifecycle = new SandboxJournal(selected, lease);
-      await lifecycle.markCleanupAttempt();
-      const worker = new SandboxWorker(config, engine, lifecycle);
-      const removed = await worker.reap(info.ID);
-      outcomes.push({ runId, status: "removed", removed });
-    } catch (error) {
-      const code = error instanceof HarnessError ? error.code : "internal_failure";
-      outcomes.push({
-        runId,
-        status: code === "run_busy" ? "busy" : "blocked",
-        removed: 0,
-        code
-      });
-    } finally {
-      if (lease)
-        await selected.release(lease).catch(() => {
-          return;
-        });
-      if (selected !== journal)
-        await selected.close();
-    }
-  }
-  return {
-    workerId: info.ID,
-    scanned: candidates.length,
-    outcomes,
-    interrupted: signal.aborted,
-    actionReplayed: false,
-    actionReconciled: false,
-    productionApproved: false
-  };
-}
-
-export { settledFailure, ToolExecutor, SandboxProbeJournal, SandboxJournal, reapSandboxes };

package/harness/chunk-jb0r19et.mjs

@@ -1,180 +0,0 @@
-import {
-  string,
-  number,
-  boolean,
-  _null,
-  unknown,
-  object,
-  union,
-  record,
-  _enum
-} from "./chunk-1sygmp11.mjs";
-
-// node_modules/.bun/@mastra+core@1.71.0+95d98e20cbc6e6e1/node_modules/@mastra/core/dist/define-vaqWwloq.js
-var AGENT_SCHEDULE_PREFIX = "agent_";
-var WORKFLOW_SCHEDULE_PREFIX = "schedule_";
-var SCHEDULE_SIGNAL_TYPES = [
-  "user",
-  "state",
-  "reactive",
-  "notification",
-  "user-message",
-  "system-reminder"
-];
-var ScheduleAttributesSchema = record(string(), union([
-  string(),
-  number(),
-  boolean(),
-  _null()
-]));
-var ScheduleStreamOptionsSchema = object({ requestContext: record(string(), unknown()).optional() });
-var ScheduleIfActiveSchema = object({
-  behavior: _enum([
-    "deliver",
-    "persist",
-    "discard"
-  ]).optional(),
-  attributes: ScheduleAttributesSchema.optional()
-});
-var ScheduleIfIdleSchema = object({
-  behavior: _enum([
-    "wake",
-    "persist",
-    "discard"
-  ]).optional(),
-  attributes: ScheduleAttributesSchema.optional(),
-  streamOptions: ScheduleStreamOptionsSchema.optional()
-});
-var ScheduleInputSchema = object({
-  scheduleId: string(),
-  agentId: string(),
-  prompt: string(),
-  threadId: string().optional(),
-  resourceId: string().optional(),
-  signalType: _enum(SCHEDULE_SIGNAL_TYPES).optional(),
-  tagName: string().optional(),
-  attributes: ScheduleAttributesSchema.optional(),
-  providerOptions: record(string(), unknown()).optional(),
-  ifActive: ScheduleIfActiveSchema.optional(),
-  ifIdle: ScheduleIfIdleSchema.optional()
-});
-var ScheduleOutputSchema = object({
-  status: _enum([
-    "fired",
-    "signal-accepted",
-    "skipped-thread-blocked",
-    "thread-missing",
-    "agent-missing",
-    "invalid-input"
-  ]),
-  reason: string().optional()
-});
-var FS_AGENT_SCHEDULE_PREFIX = "fsa_";
-function encodeRowIdPart(value) {
-  return encodeURIComponent(value).replace(/_/g, "%5F");
-}
-function fsAgentScheduleRowId(agentId, key) {
-  return `${FS_AGENT_SCHEDULE_PREFIX}${encodeRowIdPart(agentId)}__${encodeRowIdPart(key)}`;
-}
-function parseFsAgentScheduleRowId(rowId) {
-  if (!rowId.startsWith("fsa_"))
-    return;
-  const rest = rowId.slice(4);
-  const separator = rest.indexOf("__");
-  if (separator <= 0)
-    return;
-  try {
-    return {
-      agentId: decodeURIComponent(rest.slice(0, separator)),
-      key: decodeURIComponent(rest.slice(separator + 2))
-    };
-  } catch {
-    return;
-  }
-}
-
-// node_modules/.bun/@mastra+core@1.71.0+95d98e20cbc6e6e1/node_modules/@mastra/core/dist/pull-transport-D6pSbsAj.js
-var MastraWorker = class {
-  mastra;
-  deps;
-  __registerMastra(mastra) {
-    this.mastra = mastra;
-  }
-  async init(deps) {
-    this.deps = deps;
-    if (!this.mastra && deps.mastra)
-      this.mastra = deps.mastra;
-  }
-};
-var MAX_DRAIN_TIMEOUT_MS = 2147483647;
-function assertDrainTimeout(value, label) {
-  if (!Number.isFinite(value) || value < 0 || value > 2147483647)
-    throw new RangeError(`${label} drainTimeout must be a finite number of milliseconds between 0 and ${MAX_DRAIN_TIMEOUT_MS}`);
-  return value;
-}
-var TOPIC_WORKFLOWS = "workflows";
-var DEFAULT_DRAIN_TIMEOUT_MS = 5000;
-var PullTransport = class {
-  #pubsub;
-  #group;
-  #topic;
-  #logger;
-  #drainTimeout;
-  #callbacks = [];
-  #inFlight = /* @__PURE__ */ new Set;
-  constructor({ pubsub, group, topic, logger, drainTimeout }) {
-    this.#pubsub = pubsub;
-    this.#group = group;
-    this.#topic = topic ?? TOPIC_WORKFLOWS;
-    this.#logger = logger;
-    this.#drainTimeout = assertDrainTimeout(drainTimeout ?? DEFAULT_DRAIN_TIMEOUT_MS, "PullTransport");
-  }
-  async start(router) {
-    if (this.#callbacks.length > 0) {
-      this.#logger?.debug("[PullTransport] start() called while already subscribed; ignoring duplicate call");
-      return;
-    }
-    const cb = (event, ack, nack) => {
-      const inFlight = router.route(event, ack, nack).catch((err) => {
-        try {
-          if (typeof nack === "function")
-            nack();
-        } finally {
-          this.#logger?.error("[PullTransport] router.route rejected", { err });
-        }
-      });
-      this.#inFlight.add(inFlight);
-      inFlight.finally(() => this.#inFlight.delete(inFlight));
-    };
-    await this.#pubsub.subscribe(this.#topic, cb, { group: this.#group });
-    this.#callbacks.push({
-      topic: this.#topic,
-      cb
-    });
-  }
-  async stop(options) {
-    const drainTimeout = assertDrainTimeout(options?.drainTimeout ?? this.#drainTimeout, "PullTransport.stop()");
-    for (const { topic, cb } of this.#callbacks)
-      await this.#pubsub.unsubscribe(topic, cb);
-    this.#callbacks = [];
-    await this.#drainInFlight(drainTimeout);
-    await this.#pubsub.flush();
-  }
-  async#drainInFlight(drainTimeout) {
-    if (this.#inFlight.size === 0)
-      return;
-    const pending = this.#inFlight.size;
-    let timeoutHandle;
-    try {
-      if (await Promise.race([Promise.allSettled([...this.#inFlight]).then(() => false), new Promise((resolve) => {
-        timeoutHandle = setTimeout(() => resolve(true), drainTimeout);
-      })]))
-        this.#logger?.warn(`[PullTransport] stop() timed out after ${drainTimeout}ms waiting for ${pending} in-flight event(s)`);
-    } finally {
-      if (timeoutHandle)
-        clearTimeout(timeoutHandle);
-    }
-  }
-};
-
-export { AGENT_SCHEDULE_PREFIX, WORKFLOW_SCHEDULE_PREFIX, fsAgentScheduleRowId, parseFsAgentScheduleRowId, MastraWorker, assertDrainTimeout, PullTransport };