@zihin/agent-client 0.7.0 → 0.9.0

package/dist/chunk-E2AJSAPA.mjs

@@ -0,0 +1,2220 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/internal.ts
+var _utf8 = new TextEncoder();
+function utf8Len(s) {
+  return _utf8.encode(s).length;
+}
+function rec(x) {
+  return x && typeof x === "object" ? x : {};
+}
+function safeId(x) {
+  return typeof x === "string" && /^[\w.:-]{1,128}$/.test(x) ? x : void 0;
+}
+function safeLabel(x) {
+  return typeof x === "string" && /^[A-Za-z0-9_]{1,64}$/.test(x) ? x : void 0;
+}
+function str(x) {
+  return typeof x === "string" ? x : void 0;
+}
+function num(x) {
+  return typeof x === "number" ? x : void 0;
+}
+function parseUsage(usageRaw) {
+  const u = rec(usageRaw);
+  if (Object.keys(u).length === 0) return void 0;
+  return {
+    inputTokens: num(u.input_tokens) ?? num(u.prompt_tokens),
+    outputTokens: num(u.output_tokens) ?? num(u.completion_tokens),
+    totalTokens: num(u.total_tokens),
+    costUsd: num(u.cost_usd)
+  };
+}
+var RUNNING_STATUSES = /* @__PURE__ */ new Set([
+  "running",
+  "pending",
+  "queued",
+  "processing",
+  "in_progress",
+  "waiting",
+  "retrying",
+  "scheduled",
+  "awaiting_approval",
+  // HITL: turno pausado esperando decisão humana não terminou
+  // Estados VIVOS reais do backend (zihin-agent-builder `TaskService.LIVE_STATUSES` e
+  // `agent_executions.status`): sem eles, uma task/execução pausada ou aguardando input
+  // era lida como TERMINAL e o polling parava com o trabalho ainda em andamento.
+  "paused",
+  "awaiting_input"
+]);
+function isTerminalStatus(status) {
+  return !RUNNING_STATUSES.has(status.toLowerCase().replace(/-/g, "_"));
+}
+var _warnedDeprecations = /* @__PURE__ */ new Set();
+function warnDeprecatedOnce(code, message, warn) {
+  if (_warnedDeprecations.has(code)) return;
+  _warnedDeprecations.add(code);
+  try {
+    warn?.(code, message);
+  } catch {
+  }
+}
+
+// src/security.ts
+var PRIVATE_IP_PATTERNS = [
+  /^127\./,
+  // 127.0.0.0/8 (localhost)
+  /^10\./,
+  // 10.0.0.0/8 (private)
+  /^172\.(1[6-9]|2[0-9]|3[0-1])\./,
+  // 172.16.0.0/12 (private)
+  /^192\.168\./,
+  // 192.168.0.0/16 (private)
+  /^169\.254\./,
+  // 169.254.0.0/16 (link-local)
+  /^0\./
+  // 0.0.0.0/8
+];
+function parseIpv6(host) {
+  if (!host.includes(":")) return null;
+  let text = host;
+  const words = [];
+  const v4 = /(\d{1,3}(?:\.\d{1,3}){3})$/.exec(text);
+  let tail = [];
+  if (v4) {
+    const octets = v4[1].split(".").map(Number);
+    if (octets.some((o) => !Number.isInteger(o) || o < 0 || o > 255)) return null;
+    tail = [octets[0] << 8 | octets[1], octets[2] << 8 | octets[3]];
+    text = text.slice(0, v4.index).replace(/:$/, "") || "::";
+  }
+  const halves = text.split("::");
+  if (halves.length > 2) return null;
+  const toWords = (part) => {
+    if (!part) return [];
+    const out = [];
+    for (const group of part.split(":")) {
+      if (!/^[0-9a-f]{1,4}$/i.test(group)) return null;
+      out.push(parseInt(group, 16));
+    }
+    return out;
+  };
+  const head = toWords(halves[0]);
+  const rest = halves.length === 2 ? toWords(halves[1]) : [];
+  if (!head || !rest) return null;
+  if (halves.length === 2) {
+    const fill = 8 - (head.length + rest.length + tail.length);
+    if (fill < 0) return null;
+    words.push(...head, ...Array(fill).fill(0), ...rest, ...tail);
+  } else {
+    words.push(...head, ...tail);
+  }
+  return words.length === 8 ? words : null;
+}
+function isPrivateIpv6(words) {
+  const [w0, w1, w2, w3, w4, w5] = words;
+  const allZero = words.every((w) => w === 0);
+  if (allZero) return true;
+  if (words.slice(0, 7).every((w) => w === 0) && words[7] === 1) return true;
+  if (w0 === 0 && w1 === 0 && w2 === 0 && w3 === 0 && w4 === 0 && (w5 === 0 || w5 === 65535)) {
+    const v4 = `${words[6] >> 8}.${words[6] & 255}.${words[7] >> 8}.${words[7] & 255}`;
+    return PRIVATE_IP_PATTERNS.some((p) => p.test(v4));
+  }
+  if ((w0 >> 8 & 254) === 252) return true;
+  if ((w0 & 65472) === 65152) return true;
+  if ((w0 & 65472) === 65216) return true;
+  return false;
+}
+function bareHostname(hostname) {
+  const bare = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+  return bare.length > 1 && bare.endsWith(".") ? bare.replace(/\.+$/, "") : bare;
+}
+var BLOCKED_HOSTNAMES = [
+  "localhost",
+  "localtest.me",
+  "metadata.google.internal",
+  // GCP metadata
+  "169.254.169.254",
+  // AWS/Azure/GCP metadata
+  "metadata.azure.com"
+];
+var ALLOWED_ZIHIN_DOMAINS = [
+  "llm.zihin.ai",
+  "api.zihin.ai",
+  "staging.llm.zihin.ai",
+  "dev.llm.zihin.ai"
+];
+function validateBaseUrl(url, options = {}) {
+  if (!url || url.trim() === "") {
+    return { valid: true, sanitizedUrl: "https://llm.zihin.ai" };
+  }
+  try {
+    const parsed = new URL(url);
+    if (parsed.hostname.length > 1 && parsed.hostname.endsWith(".")) {
+      parsed.hostname = parsed.hostname.replace(/\.+$/, "");
+    }
+    const hostname = bareHostname(parsed.hostname);
+    const isLocalhost = hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
+    if (isLocalhost && options.allowLocalhost) {
+      const sanitizedUrl2 = parsed.origin + parsed.pathname.replace(/\/+$/, "");
+      return { valid: true, sanitizedUrl: sanitizedUrl2 };
+    }
+    if (!options.allowHttp && parsed.protocol !== "https:") {
+      return {
+        valid: false,
+        error: "Only HTTPS URLs are allowed for security reasons"
+      };
+    }
+    const ipv6 = parseIpv6(hostname);
+    if (ipv6) {
+      if (isPrivateIpv6(ipv6)) {
+        return { valid: false, error: "Private IP addresses are not allowed" };
+      }
+    } else {
+      for (const pattern of PRIVATE_IP_PATTERNS) {
+        if (pattern.test(hostname)) {
+          return { valid: false, error: "Private IP addresses are not allowed" };
+        }
+      }
+    }
+    for (const blocked of BLOCKED_HOSTNAMES) {
+      if (blocked.startsWith("*")) {
+        const suffix = blocked.slice(1);
+        if (hostname.endsWith(suffix)) {
+          return { valid: false, error: "This hostname is not allowed" };
+        }
+      } else if (hostname === blocked || hostname.endsWith("." + blocked)) {
+        return { valid: false, error: "This hostname is not allowed" };
+      }
+    }
+    if (!options.allowCustomDomains) {
+      const isAllowed = ALLOWED_ZIHIN_DOMAINS.some(
+        (domain) => hostname === domain || hostname.endsWith("." + domain)
+      );
+      if (!isAllowed) {
+        return {
+          valid: false,
+          error: `Only Zihin domains are allowed. Use 'allowCustomBaseUrl' for custom endpoints.`
+        };
+      }
+    }
+    const sanitizedUrl = parsed.origin + parsed.pathname.replace(/\/+$/, "");
+    return { valid: true, sanitizedUrl };
+  } catch {
+    return { valid: false, error: "Invalid URL format" };
+  }
+}
+var DEFAULT_LIMITS = {
+  maxPromptBytes: 100 * 1024,
+  // 100KB
+  maxMessageCount: 100,
+  maxSingleMessageBytes: 50 * 1024,
+  // 50KB
+  maxTotalPayloadBytes: 500 * 1024
+  // 500KB
+};
+function validatePromptSize(prompt, limits = {}) {
+  const effectiveLimits = { ...DEFAULT_LIMITS, ...limits };
+  const bytes = utf8Len(prompt);
+  if (bytes > effectiveLimits.maxPromptBytes) {
+    return {
+      valid: false,
+      error: `Prompt size (${Math.round(bytes / 1024)}KB) exceeds maximum allowed (${Math.round(
+        effectiveLimits.maxPromptBytes / 1024
+      )}KB)`,
+      details: { promptBytes: bytes }
+    };
+  }
+  return { valid: true, details: { promptBytes: bytes } };
+}
+var SENSITIVE_PATTERNS = [
+  /zhn_(?:live|test|dev)_[a-zA-Z0-9]+/g,
+  // API keys
+  /Bearer\s+[a-zA-Z0-9._-]+/gi,
+  // Bearer tokens
+  /at\s+[\w./<>]+\s*\(.*:\d+:\d+\)/g,
+  // Stack trace lines
+  /^\s+at\s+.+$/gm,
+  // Stack traces
+  /Error:\s*.*\n\s+at/g
+  // Error stack beginnings
+];
+var ERROR_CODE_MAP = {
+  RATE_LIMIT_EXCEEDED: "Rate limit exceeded. Please wait before retrying.",
+  UNAUTHORIZED: "Authentication failed. Please check your API credentials.",
+  FORBIDDEN: "This API key's role does not allow this action. The required role depends on the endpoint \u2014 check the key's role in Zihin \u2192 Settings \u2192 API Keys.",
+  INVALID_MODEL: "The specified model is not available.",
+  INTERNAL_ERROR: "An internal error occurred. Please try again later.",
+  TIMEOUT: "Request timed out. Try increasing the timeout.",
+  INVALID_REQUEST: "The request was malformed. Please check your input.",
+  INSUFFICIENT_CREDITS: "Insufficient credits. Please check your account balance.",
+  CONTEXT_LENGTH_EXCEEDED: "The input exceeds the model context length limit.",
+  AGENT_NOT_FOUND: "Agent not found or not active for this tenant.",
+  // Nome novo do `AGENT_NOT_FOUND` (zihin-agent-builder#561, fatia B). `AGENT_ERROR` virou
+  // `INTERNAL_ERROR`, que já está acima.
+  NOT_FOUND: "Resource not found \u2014 check the ID (agent, trigger or execution) and that it belongs to this workspace.",
+  // Bloqueios comerciais. As mensagens do BE vêm em português e estes shells são em inglês;
+  // além disso cada caso tem uma ação DIFERENTE, e o texto precisa dizer qual.
+  TRIAL_EXPIRED: "Your Zihin trial has ended. Upgrade the plan to keep invoking agents \u2014 the API key is fine.",
+  QUOTA_EXCEEDED: "Your Zihin token quota is exhausted. Upgrade the plan or wait for the next cycle \u2014 retrying will not help, and the API key is fine.",
+  NO_ACTIVE_SUBSCRIPTION: "This tenant has no active Zihin subscription. Activate a plan to invoke agents \u2014 the API key is fine."
+};
+function sanitizeApiError(error) {
+  let message = "An unexpected error occurred";
+  let code;
+  let retryable = false;
+  let retryAfter;
+  if (typeof error === "object" && error !== null) {
+    const err = error;
+    const nested = err.error && typeof err.error === "object" ? err.error : void 0;
+    const codeRaw = nested?.code ?? (typeof err.error === "string" ? err.error : err.code);
+    code = typeof codeRaw === "string" ? codeRaw : void 0;
+    const rawMessage = nested?.message ?? err.message;
+    const reason = typeof err.reason === "string" ? err.reason : void 0;
+    const effectiveCode = code === "QUOTA_EXCEEDED" && reason === "no_active_subscription" ? "NO_ACTIVE_SUBSCRIPTION" : code;
+    if (effectiveCode && ERROR_CODE_MAP[effectiveCode]) {
+      message = ERROR_CODE_MAP[effectiveCode];
+    } else if (typeof rawMessage === "string" && rawMessage) {
+      message = rawMessage;
+    }
+    if (code === "RATE_LIMIT_EXCEEDED" || code === "TIMEOUT") {
+      retryable = true;
+      retryAfter = err.retryAfter || 60;
+    }
+    if (message.length > 2e3) message = message.slice(0, 2e3);
+    for (const pattern of SENSITIVE_PATTERNS) {
+      message = message.replace(pattern, "[REDACTED]");
+    }
+  } else if (typeof error === "string") {
+    message = error;
+    if (message.length > 2e3) message = message.slice(0, 2e3);
+    for (const pattern of SENSITIVE_PATTERNS) {
+      message = message.replace(pattern, "[REDACTED]");
+    }
+  }
+  if (message.length > 500) {
+    message = message.substring(0, 500) + "...";
+  }
+  return { message, code, retryable, retryAfter };
+}
+var API_KEY_PATTERN = /^zhn_(live|test|dev)_[a-zA-Z0-9]{20,}$/;
+function validateApiKeyFormat(apiKey) {
+  if (!apiKey || apiKey.trim() === "") {
+    return { valid: false, error: "API key is required" };
+  }
+  const trimmed = apiKey.trim();
+  if (!API_KEY_PATTERN.test(trimmed)) {
+    return {
+      valid: false,
+      error: "Invalid API key format. Expected: zhn_live_xxx, zhn_test_xxx or zhn_dev_xxx"
+    };
+  }
+  const environment = trimmed.startsWith("zhn_live_") ? "live" : trimmed.startsWith("zhn_test_") ? "test" : "dev";
+  return { valid: true, environment };
+}
+
+// src/errors.ts
+var ZihinAgentError = class _ZihinAgentError extends Error {
+  constructor(kind, message, opts = {}) {
+    super(buildMessage(message, opts));
+    this.name = "ZihinAgentError";
+    this.kind = kind;
+    this.status = opts.status;
+    this.code = opts.code;
+    this.requestId = opts.requestId;
+    this.executionId = opts.executionId;
+    this.sessionId = opts.sessionId;
+    this.timeoutClock = opts.timeoutClock;
+    this.attempts = opts.attempts;
+    this.endpoint = opts.endpoint;
+    this.retryable = opts.retryable ?? (kind === "rate_limit" || kind === "server" || kind === "network");
+    Object.setPrototypeOf(this, _ZihinAgentError.prototype);
+  }
+};
+function buildMessage(base, opts) {
+  let s = base;
+  if (opts.endpoint) s += ` [${opts.endpoint}]`;
+  if (opts.attempts && opts.attempts > 1) s += ` (after ${opts.attempts} attempts)`;
+  if (opts.requestId) s += ` (request_id: ${opts.requestId})`;
+  if (opts.executionId) s += ` (execution_id: ${opts.executionId})`;
+  return s;
+}
+var COMMERCIAL_BLOCK_CODES = /* @__PURE__ */ new Set(["TRIAL_EXPIRED", "QUOTA_EXCEEDED", "NO_ACTIVE_SUBSCRIPTION"]);
+function errorCodeOf(body) {
+  const b = rec(body);
+  return str(b.error) ?? str(rec(b.error).code) ?? str(b.code);
+}
+function isCommercialBlock(body) {
+  const code = errorCodeOf(body);
+  return code !== void 0 && COMMERCIAL_BLOCK_CODES.has(code);
+}
+function commercialKind(body) {
+  const code = errorCodeOf(body);
+  if (code === "TRIAL_EXPIRED") return "trial_expired";
+  if (code === "NO_ACTIVE_SUBSCRIPTION") return "no_subscription";
+  if (code === "QUOTA_EXCEEDED") {
+    return str(rec(body).reason) === "no_active_subscription" ? "no_subscription" : "quota_exceeded";
+  }
+  return void 0;
+}
+function extractRequestId(body) {
+  const b = rec(body);
+  return safeId(b.request_id) ?? safeId(b.requestId) ?? safeId(rec(b.error).request_id) ?? safeId(rec(b.meta).request_id);
+}
+function errorFromResponse(status, body, meta = {}) {
+  const sanitized = sanitizeApiError(body);
+  const message = sanitized.message;
+  const code = sanitized.code;
+  const base = {
+    status,
+    code,
+    requestId: extractRequestId(body),
+    executionId: safeId(rec(body).execution_id),
+    ...meta
+  };
+  const commercial = commercialKind(body);
+  if (commercial) {
+    return new ZihinAgentError(commercial, message || "Request blocked by your plan.", {
+      ...base,
+      retryable: false
+    });
+  }
+  if (code === "PLAN_LIMIT_REACHED")
+    return new ZihinAgentError("blocked", message || "This feature is not available on your Zihin plan.", { ...base, retryable: false });
+  if (status === 401) return new ZihinAgentError("auth", message || "Authentication failed.", base);
+  if (status === 403 && str(rec(rec(rec(body).error).details).reason) === "AGENT_ACCESS_DENIED")
+    return new ZihinAgentError(
+      "not_found",
+      "Agent not found, inactive, or not accessible with this API key \u2014 check the agent ID and that the key belongs to the same Zihin workspace.",
+      { ...base, retryable: false }
+    );
+  if (status === 403)
+    return new ZihinAgentError(
+      "auth",
+      // Não enumerar papéis aqui: o papel exigido varia por rota (triggers aceitam editor,
+      // mas delegar/cancelar uma task exige admin/owner). A frase antiga mandava o usuário
+      // para o papel errado em metade da API.
+      message || "This API key's role does not allow this action. The required role depends on the endpoint \u2014 check the key's role in Zihin \u2192 Settings \u2192 API Keys.",
+      base
+    );
+  if (status === 404) return new ZihinAgentError("not_found", message || "Resource not found.", base);
+  if (status === 408)
+    return new ZihinAgentError("timeout", message || "The server timed out handling the request.", {
+      ...base,
+      retryable: true
+    });
+  if (status === 429)
+    return new ZihinAgentError("rate_limit", message || "Rate limit exceeded.", { ...base, retryable: true });
+  if (status >= 500)
+    return new ZihinAgentError("server", message || `Server error (${status}).`, { ...base, retryable: true });
+  return new ZihinAgentError("unknown", message || `Request failed (${status}).`, base);
+}
+var NON_RETRYABLE_NET = /^(ENOTFOUND|EAI_AGAIN|CERT_|ERR_TLS|UNABLE_TO_VERIFY|DEPTH_ZERO)/;
+function errorFromThrow(err, timeoutMs, meta = {}) {
+  if (err instanceof ZihinAgentError) return err;
+  const name = err?.name;
+  if (name === "TimeoutError") {
+    return new ZihinAgentError("timeout", `Request timed out after ${timeoutMs ?? "?"}ms.`, {
+      ...meta,
+      retryable: false
+    });
+  }
+  if (name === "AbortError") {
+    return new ZihinAgentError("aborted", "Request was aborted by the caller.", { ...meta, retryable: false });
+  }
+  const cause = err?.cause;
+  const causeCode = cause?.code;
+  const sanitized = sanitizeApiError(err);
+  const detail = causeCode || sanitized.message || "Network error";
+  const retryable = causeCode ? !NON_RETRYABLE_NET.test(causeCode) : true;
+  return new ZihinAgentError("network", `Network error: ${detail}`, { ...meta, retryable });
+}
+
+// src/http.ts
+var DEFAULT_BASE_URL = "https://llm.zihin.ai";
+var OPERATION_TIMEOUT_MS = Object.freeze({
+  stream: 2e5,
+  dispatch: 26e4,
+  short: 35e3
+});
+var DEADLINE_GRACE_MS = 3e4;
+var RETRY_OVERHEAD_MS = 6e4;
+var MIN_TIMEOUT_MS = 1e3;
+var MAX_TIMEOUT_MS = 9e5;
+function normalizeTimeoutMs(value, label = "timeoutMs") {
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(n) || n <= 0) {
+    throw new ZihinAgentError(
+      "config",
+      `${label} must be a positive number of milliseconds (got ${JSON.stringify(value)}).`
+    );
+  }
+  return Math.min(Math.max(n, MIN_TIMEOUT_MS), MAX_TIMEOUT_MS);
+}
+var DEFAULT_MAX_RETRIES = 2;
+var DEFAULT_MAX_EVENT_BYTES = 1 * 1024 * 1024;
+var DEFAULT_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+function globalFetch() {
+  return typeof fetch === "function" ? fetch : void 0;
+}
+function resolveFetch(injected) {
+  const f = injected ?? globalFetch();
+  if (typeof f !== "function") {
+    throw new ZihinAgentError("config", "Global fetch is unavailable in this runtime.");
+  }
+  return f;
+}
+function resolveConfig(config) {
+  const keyCheck = validateApiKeyFormat(config.apiKey ?? "");
+  if (!keyCheck.valid) {
+    throw new ZihinAgentError("config", keyCheck.error || "Invalid API key.");
+  }
+  const urlCheck = validateBaseUrl(config.baseUrl ?? "", {
+    allowCustomDomains: config.allowCustomBaseUrl,
+    allowHttp: config.allowHttp,
+    allowLocalhost: config.allowHttp
+  });
+  if (!urlCheck.valid) {
+    throw new ZihinAgentError("config", urlCheck.error || "Invalid base URL.");
+  }
+  if (typeof config.runtime?.sleep !== "function") {
+    throw new ZihinAgentError(
+      "config",
+      'A runtime is required: import from "@zihin/agent-client" (default runtime) or pass `runtime` to the "@zihin/agent-client/core" client.'
+    );
+  }
+  if (typeof (config.fetch ?? globalFetch()) !== "function") {
+    throw new ZihinAgentError(
+      "config",
+      "Global fetch is unavailable in this runtime. Use Node >=20.16 or pass a `fetch` implementation in the client config."
+    );
+  }
+  return {
+    apiKey: config.apiKey.trim(),
+    baseUrl: urlCheck.sanitizedUrl || DEFAULT_BASE_URL,
+    timeoutMs: config.timeoutMs === void 0 || config.timeoutMs === null ? void 0 : normalizeTimeoutMs(config.timeoutMs, "timeoutMs"),
+    maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,
+    maxStreamEventBytes: config.maxStreamEventBytes ?? DEFAULT_MAX_EVENT_BYTES,
+    maxStreamTotalBytes: config.maxStreamTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES,
+    fetchImpl: config.fetch,
+    runtime: config.runtime,
+    onRetry: config.onRetry,
+    onError: config.onError
+  };
+}
+function resolveTimeout(cfg, operation) {
+  return cfg.timeoutMs ?? OPERATION_TIMEOUT_MS[operation];
+}
+function endpointLabel(method, url) {
+  try {
+    const u = new URL(url);
+    return `${method} ${u.host}${u.pathname}`;
+  } catch {
+    return method;
+  }
+}
+function retryAfterMs(headers, capMs = 3e4) {
+  const raw = headers.get("retry-after");
+  if (!raw) return void 0;
+  const secs = Number(raw);
+  if (Number.isFinite(secs)) return Math.min(Math.max(0, secs * 1e3), capMs);
+  const when = Date.parse(raw);
+  if (Number.isFinite(when)) return Math.min(Math.max(0, when - Date.now()), capMs);
+  return void 0;
+}
+function buildHeaders(apiKey, extra = {}) {
+  return {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "X-Api-Key": apiKey,
+    ...extra
+  };
+}
+async function delay(runtime, ms, signal, meta) {
+  const aborted = () => new ZihinAgentError("aborted", "Request was aborted by the caller.", meta);
+  if (signal?.aborted) throw aborted();
+  try {
+    await runtime.sleep(ms, signal);
+  } catch {
+    throw aborted();
+  }
+}
+function backoffMs(attempt) {
+  const base = Math.min(1e3 * 2 ** attempt, 1e4);
+  return base / 2 + Math.random() * (base / 2);
+}
+function createDeadline(runtime, timeoutMs, callerSignal) {
+  const controller = new AbortController();
+  const clock = new AbortController();
+  let timedOut = false;
+  let abortedByCaller = false;
+  runtime.sleep(timeoutMs, clock.signal).then(
+    () => {
+      timedOut = true;
+      controller.abort();
+    },
+    () => {
+    }
+  );
+  const onAbort = () => {
+    abortedByCaller = true;
+    controller.abort();
+  };
+  if (callerSignal) {
+    if (callerSignal.aborted) onAbort();
+    else callerSignal.addEventListener("abort", onAbort, { once: true });
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      clock.abort();
+      if (callerSignal) callerSignal.removeEventListener("abort", onAbort);
+    },
+    timedOut: () => timedOut,
+    abortedByCaller: () => abortedByCaller
+  };
+}
+function shouldRetryStatus(status, policy) {
+  if (policy === "idempotent") return status >= 500 || status === 429 || status === 408;
+  return status === 429 || status === 503;
+}
+function budgetTracker(args) {
+  const startedAt = Date.now();
+  const reported = args.reportedTimeoutMs ?? args.timeoutMs;
+  const overheadCap = Math.min(args.timeoutMs, RETRY_OVERHEAD_MS);
+  return {
+    reported,
+    /** Quanto ainda pode ser gasto com tentativas falhas + backoff. */
+    overheadLeft: () => overheadCap - (Date.now() - startedAt),
+    expired: (attempts) => new ZihinAgentError("timeout", `Request timed out after ${reported}ms.`, {
+      endpoint: args.endpoint,
+      attempts
+    })
+  };
+}
+async function requestBuffered(args) {
+  const endpoint = endpointLabel(args.method, args.url);
+  const doFetch = resolveFetch(args.fetchImpl);
+  const budget = budgetTracker({ ...args, endpoint });
+  let lastError = null;
+  for (let attempt = 0; attempt <= args.maxRetries; attempt++) {
+    const d = createDeadline(args.runtime, args.timeoutMs, args.callerSignal);
+    try {
+      const res = await doFetch(args.url, {
+        method: args.method,
+        headers: args.headers,
+        body: args.body,
+        signal: d.signal,
+        redirect: "error",
+        // 3xx para outro host vazaria a X-Api-Key
+        cache: "no-store"
+        // evita cache stale (ex.: polling em Next.js/edge)
+      });
+      let wait = shouldRetryStatus(res.status, args.policy) && attempt < args.maxRetries ? retryAfterMs(res.headers) ?? backoffMs(attempt) : null;
+      let peeked;
+      if (wait !== null && res.status === 429) {
+        peeked = await res.text();
+        if (isCommercialBlock(parseBody(peeked))) wait = null;
+      }
+      if (wait !== null && budget.overheadLeft() > wait) {
+        if (peeked === void 0) {
+          try {
+            await res.body?.cancel();
+          } catch {
+          }
+        }
+        d.dispose();
+        args.onRetry?.({ endpoint, attempt: attempt + 1, delayMs: wait, reason: "status", status: res.status });
+        await delay(args.runtime, wait, args.callerSignal, { endpoint, attempts: attempt + 1 });
+        continue;
+      }
+      const text = peeked ?? await res.text();
+      d.dispose();
+      return { status: res.status, ok: res.ok, text, endpoint, attempts: attempt + 1 };
+    } catch (err) {
+      d.dispose();
+      if (err instanceof ZihinAgentError) throw err;
+      const meta = { endpoint, attempts: attempt + 1 };
+      if (d.timedOut()) throw budget.expired(attempt + 1);
+      if (d.abortedByCaller())
+        throw new ZihinAgentError("aborted", "Request was aborted by the caller.", meta);
+      lastError = errorFromThrow(err, budget.reported, meta);
+      const canRetry = args.policy === "idempotent" && lastError.retryable && attempt < args.maxRetries;
+      if (!canRetry) throw lastError;
+      const wait = backoffMs(attempt);
+      if (budget.overheadLeft() <= wait) throw lastError;
+      args.onRetry?.({ endpoint, attempt: attempt + 1, delayMs: wait, reason: "network" });
+      await delay(args.runtime, wait, args.callerSignal, { endpoint, attempts: attempt + 1 });
+    }
+  }
+  throw lastError ?? new ZihinAgentError("unknown", "Max retries exceeded.", { endpoint });
+}
+async function openStream(args) {
+  const endpoint = endpointLabel("POST", args.url);
+  const doFetch = resolveFetch(args.fetchImpl);
+  const budget = budgetTracker({ ...args, endpoint });
+  const policy = args.idempotent ? "idempotent" : "side-effecting";
+  for (let attempt = 0; attempt <= args.maxRetries; attempt++) {
+    const d = createDeadline(args.runtime, args.timeoutMs, args.callerSignal);
+    try {
+      const response = await doFetch(args.url, {
+        method: "POST",
+        headers: { ...args.headers, Accept: "text/event-stream" },
+        body: args.body,
+        signal: d.signal,
+        redirect: "error",
+        cache: "no-store"
+      });
+      let wait = shouldRetryStatus(response.status, policy) && attempt < args.maxRetries ? retryAfterMs(response.headers) ?? backoffMs(attempt) : null;
+      if (response.status === 429) {
+        const text = await response.text().catch(() => "");
+        const body = parseBody(text);
+        if (wait === null || isCommercialBlock(body) || budget.overheadLeft() <= wait) {
+          d.dispose();
+          throw errorFromResponse(response.status, body, { endpoint, attempts: attempt + 1 });
+        }
+        d.dispose();
+        args.onRetry?.({ endpoint, attempt: attempt + 1, delayMs: wait, reason: "status", status: 429 });
+        await delay(args.runtime, wait, args.callerSignal, { endpoint, attempts: attempt + 1 });
+        continue;
+      }
+      if (wait !== null && budget.overheadLeft() > wait) {
+        try {
+          await response.body?.cancel();
+        } catch {
+        }
+        d.dispose();
+        args.onRetry?.({
+          endpoint,
+          attempt: attempt + 1,
+          delayMs: wait,
+          reason: "status",
+          status: response.status
+        });
+        await delay(args.runtime, wait, args.callerSignal, { endpoint, attempts: attempt + 1 });
+        continue;
+      }
+      return { response, deadline: d, endpoint };
+    } catch (err) {
+      d.dispose();
+      if (err instanceof ZihinAgentError) throw err;
+      const meta = { endpoint, attempts: attempt + 1 };
+      if (d.timedOut()) throw budget.expired(attempt + 1);
+      if (d.abortedByCaller())
+        throw new ZihinAgentError("aborted", "Request was aborted by the caller.", meta);
+      const netErr = errorFromThrow(err, budget.reported, meta);
+      const wait = backoffMs(attempt);
+      if (policy === "idempotent" && netErr.retryable && attempt < args.maxRetries && budget.overheadLeft() > wait) {
+        args.onRetry?.({ endpoint, attempt: attempt + 1, delayMs: wait, reason: "network" });
+        await delay(args.runtime, wait, args.callerSignal, { endpoint, attempts: attempt + 1 });
+        continue;
+      }
+      throw netErr;
+    }
+  }
+  throw new ZihinAgentError("unknown", "Max retries exceeded.", { endpoint });
+}
+function toJsonBody(value, label = "body") {
+  try {
+    return JSON.stringify(value);
+  } catch (err) {
+    throw new ZihinAgentError(
+      "config",
+      `${label} is not JSON-serializable: ${err?.message ?? "unknown reason"}.`
+    );
+  }
+}
+async function requestJson(cfg, args) {
+  const res = await requestBuffered({
+    method: args.method,
+    url: `${cfg.baseUrl}${args.path}`,
+    headers: buildHeaders(cfg.apiKey),
+    body: args.body !== void 0 ? toJsonBody(args.body) : void 0,
+    timeoutMs: resolveTimeout(cfg, args.operation ?? "short"),
+    maxRetries: cfg.maxRetries,
+    policy: args.policy,
+    callerSignal: args.signal,
+    fetchImpl: cfg.fetchImpl,
+    runtime: cfg.runtime,
+    onRetry: cfg.onRetry
+  });
+  if (!res.ok) {
+    throw errorFromResponse(res.status, parseBody(res.text), {
+      endpoint: res.endpoint,
+      attempts: res.attempts
+    });
+  }
+  try {
+    return JSON.parse(res.text);
+  } catch {
+    throw new ZihinAgentError("protocol", "Expected JSON response.", { endpoint: res.endpoint });
+  }
+}
+function parseBody(text) {
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { message: text };
+  }
+}
+
+// src/agents.ts
+async function listAgents(cfg, opts = {}) {
+  const res = await requestBuffered({
+    method: "GET",
+    url: `${cfg.baseUrl}/api/v2/agents`,
+    headers: buildHeaders(cfg.apiKey),
+    timeoutMs: resolveTimeout(cfg, "short"),
+    maxRetries: cfg.maxRetries,
+    policy: "idempotent",
+    callerSignal: opts.signal,
+    fetchImpl: cfg.fetchImpl,
+    runtime: cfg.runtime,
+    onRetry: cfg.onRetry
+  });
+  if (!res.ok) {
+    throw errorFromResponse(res.status, parseBody(res.text), { endpoint: res.endpoint, attempts: res.attempts });
+  }
+  let json;
+  try {
+    json = JSON.parse(res.text);
+  } catch {
+    throw new ZihinAgentError("protocol", "Expected JSON from GET /api/v2/agents.");
+  }
+  const data = rec(json).data;
+  const list = Array.isArray(data) ? data : [];
+  return list.map((item) => {
+    const a = rec(item);
+    return {
+      id: str(a.id) ?? "",
+      name: str(a.name),
+      commercialName: str(a.commercial_name),
+      bio: str(a.bio),
+      type: str(a.type),
+      status: str(a.status),
+      tags: Array.isArray(a.tags) ? a.tags.filter((t) => typeof t === "string") : void 0,
+      toolsCount: typeof a.tools_count === "number" ? a.tools_count : void 0
+    };
+  });
+}
+
+// src/sse.ts
+var DEFAULT_MAX_EVENT_BYTES2 = 1 * 1024 * 1024;
+var DEFAULT_MAX_TOTAL_BYTES2 = 64 * 1024 * 1024;
+async function* parseSse(response, opts = {}) {
+  if (!response.body) {
+    throw new ZihinAgentError("protocol", "SSE response has no body.");
+  }
+  const maxEventBytes = opts.maxEventBytes ?? DEFAULT_MAX_EVENT_BYTES2;
+  const maxTotalBytes = opts.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES2;
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let eventName = "";
+  let dataLines = [];
+  let dataBytes = 0;
+  let totalBytes = 0;
+  const flush = () => {
+    const had = dataLines.length > 0 || eventName !== "";
+    const rawData = dataLines.join("\n");
+    const evt = eventName || "message";
+    eventName = "";
+    dataLines = [];
+    dataBytes = 0;
+    if (!had || rawData === "") return null;
+    let data = rawData;
+    try {
+      data = JSON.parse(rawData);
+    } catch {
+    }
+    return { event: evt, data, rawData };
+  };
+  try {
+    while (true) {
+      if (opts.signal?.aborted) {
+        throw opts.onAbortError ? opts.onAbortError() : new ZihinAgentError("aborted", "Stream aborted.");
+      }
+      let chunk;
+      try {
+        chunk = await reader.read();
+      } catch (err) {
+        throw opts.onAbortError ? opts.onAbortError() : errorFromThrow(err);
+      }
+      if (chunk.done) break;
+      totalBytes += chunk.value.byteLength;
+      if (totalBytes > maxTotalBytes) {
+        throw new ZihinAgentError("protocol", `SSE stream exceeded ${maxTotalBytes} bytes.`);
+      }
+      buffer += decoder.decode(chunk.value, { stream: true });
+      let nl;
+      while ((nl = buffer.indexOf("\n")) !== -1) {
+        let line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        if (line.endsWith("\r")) line = line.slice(0, -1);
+        if (line === "") {
+          const e = flush();
+          if (e) yield e;
+          continue;
+        }
+        if (line.startsWith(":")) continue;
+        const colon = line.indexOf(":");
+        const field = colon === -1 ? line : line.slice(0, colon);
+        let val = colon === -1 ? "" : line.slice(colon + 1);
+        if (val.startsWith(" ")) val = val.slice(1);
+        if (field === "event") {
+          eventName = val;
+        } else if (field === "data") {
+          dataBytes += utf8Len(val) + 1;
+          if (dataBytes > maxEventBytes) {
+            throw new ZihinAgentError("protocol", `SSE event exceeded ${maxEventBytes} bytes.`);
+          }
+          dataLines.push(val);
+        }
+      }
+      if (utf8Len(buffer) > maxEventBytes) {
+        throw new ZihinAgentError("protocol", `SSE line exceeded ${maxEventBytes} bytes.`);
+      }
+    }
+    buffer += decoder.decode();
+    if (buffer.length > 0) {
+      let line = buffer.endsWith("\r") ? buffer.slice(0, -1) : buffer;
+      if (line && !line.startsWith(":")) {
+        const colon = line.indexOf(":");
+        const field = colon === -1 ? line : line.slice(0, colon);
+        let val = colon === -1 ? "" : line.slice(colon + 1);
+        if (val.startsWith(" ")) val = val.slice(1);
+        if (field === "data") dataLines.push(val);
+        else if (field === "event") eventName = val;
+      }
+    }
+    const tail = flush();
+    if (tail) yield tail;
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {
+    }
+    opts.onEnd?.();
+  }
+}
+
+// src/invoke.ts
+function parseAcceptedFields(v) {
+  if (!Array.isArray(v)) return void 0;
+  return v.map((x) => safeId(typeof x === "string" ? x : str(rec(x).field) ?? str(rec(x).name))).filter((x) => !!x);
+}
+function parseIgnoredFields(v) {
+  if (!Array.isArray(v)) return void 0;
+  const out = [];
+  for (const x of v) {
+    const field = safeId(typeof x === "string" ? x : str(rec(x).field) ?? str(rec(x).name));
+    if (field) out.push(typeof x === "string" ? { field } : { field, reason: safeLabel(rec(x).reason) });
+  }
+  return out;
+}
+var MAX_SUGGESTIONS = 10;
+var MAX_SUGGESTION_CHARS = 200;
+function suggestionsFromBlocks(blocks) {
+  if (!Array.isArray(blocks)) return void 0;
+  const qr = [...blocks].reverse().find((b) => rec(b).type === "quick_replies");
+  const labels = rec(rec(qr).data).labels;
+  if (!Array.isArray(labels)) return void 0;
+  const out = labels.filter((l) => typeof l === "string" && l.trim().length > 0 && l.length <= MAX_SUGGESTION_CHARS).slice(0, MAX_SUGGESTIONS);
+  return out.length ? out : void 0;
+}
+function turnIds(d) {
+  return {
+    executionId: safeId(d.execution_id),
+    clientMessageId: safeId(d.client_message_id),
+    idempotentReplay: d.idempotent_replay === true ? true : void 0,
+    userMessageId: safeId(d.user_message_id),
+    assistantMessageId: safeId(d.assistant_message_id)
+  };
+}
+function mapEvent(e) {
+  const d = rec(e.data);
+  switch (e.event) {
+    case "metadata":
+      return {
+        type: "metadata",
+        requestId: safeId(d.request_id),
+        agentId: str(d.agent_id),
+        sessionId: safeId(d.session_id),
+        ...turnIds(d),
+        acceptedFields: parseAcceptedFields(d.accepted_fields),
+        ignoredFields: parseIgnoredFields(d.ignored_fields),
+        data: e.data
+      };
+    case "status":
+      return { type: "status", phase: str(d.phase), blocked: safeLabel(d.blocked), data: e.data };
+    case "attachments":
+      return { type: "attachments", data: e.data };
+    case "phase":
+      return { type: "phase", phase: str(d.phase), data: e.data };
+    case "thinking":
+      return { type: "thinking", thought: str(d.thought), data: e.data };
+    case "tool":
+      return {
+        type: "tool",
+        tool: str(d.tool),
+        callId: str(d.call_id),
+        success: typeof d.success === "boolean" ? d.success : void 0,
+        data: e.data
+      };
+    case "action_proposed":
+      return { type: "action_proposed", data: e.data };
+    case "action_forwarded":
+      return { type: "action_forwarded", actionId: safeId(d.action_id), data: e.data };
+    case "token":
+      return { type: "token", content: str(d.content) ?? "", data: e.data };
+    case "warning":
+      return { type: "warning", message: str(d.message), data: e.data };
+    case "session":
+      return { type: "session", sessionId: safeId(d.session_id), data: e.data };
+    case "done":
+      return {
+        type: "done",
+        outcome: safeLabel(d.outcome),
+        timedOut: typeof d.timed_out === "boolean" ? d.timed_out : void 0,
+        timeoutClock: safeLabel(d.timeout_clock),
+        truncated: typeof d.truncated === "boolean" ? d.truncated : void 0,
+        finishReason: str(d.finish_reason),
+        ...turnIds(d),
+        data: e.data
+      };
+    case "error": {
+      const err = rec(d.error);
+      return {
+        type: "error",
+        code: safeLabel(err.code),
+        message: str(err.message),
+        requestId: safeId(err.request_id),
+        timedOut: typeof err.timed_out === "boolean" ? err.timed_out : void 0,
+        data: e.data
+      };
+    }
+    case "response":
+      return {
+        type: "response",
+        content: str(d.content) ?? "",
+        sessionId: safeId(d.session_id),
+        gated: d.gated === true ? true : void 0,
+        sources: Array.isArray(d.sources) ? d.sources : void 0,
+        blocks: Array.isArray(d.blocks) ? d.blocks : void 0,
+        suggestions: suggestionsFromBlocks(d.blocks),
+        ...turnIds(d),
+        data: e.data
+      };
+    case "metrics": {
+      const modelConfig = rec(d.model_config);
+      return {
+        type: "metrics",
+        usage: parseUsage(d.usage),
+        model: str(modelConfig.model) ?? str(d.model),
+        iterations: num(d.iterations),
+        executionTimeMs: num(d.execution_time_ms),
+        executionId: safeId(d.execution_id),
+        data: e.data
+      };
+    }
+    default:
+      return { type: "unknown", event: e.event, data: e.data };
+  }
+}
+function buildRequestBody(params, normalizedTimeoutMs) {
+  const body = {};
+  if (params.message !== void 0) body.message = params.message;
+  if (params.sessionId) body.session_id = params.sessionId;
+  if (params.clientMessageId) body.client_message_id = params.clientMessageId;
+  if (params.consumerKey) body.consumer_key = params.consumerKey;
+  if (params.consumer?.name !== void 0) body.consumer_display_name = params.consumer.name;
+  if (params.capabilities?.blocks?.length) body.capabilities = { blocks: [...params.capabilities.blocks] };
+  if (params.context) body.context = { ...params.context };
+  if (params.bindings) body.bindings = { ...params.bindings };
+  if (params.sessionFrom?.length) body.session_from = [...params.sessionFrom];
+  if (params.attachments?.length) {
+    body.attachments = params.attachments.map((a) => ({ url: a.url, type: a.type }));
+  }
+  if (params.options) {
+    const o = {};
+    if (params.options.temperature !== void 0) o.temperature = params.options.temperature;
+    if (params.options.maxTokens !== void 0) o.max_tokens = params.options.maxTokens;
+    if (normalizedTimeoutMs !== void 0) o.timeout_ms = normalizedTimeoutMs;
+    if (params.options.jitMode !== void 0) o.jit_mode = params.options.jitMode;
+    if (Object.keys(o).length) body.options = o;
+  }
+  if (params.metadata) {
+    const m = { ...params.metadata };
+    if (params.metadata.traceId !== void 0) {
+      m.trace_id = params.metadata.traceId;
+      delete m.traceId;
+    }
+    if (params.metadata.correlationId !== void 0) {
+      m.correlation_id = params.metadata.correlationId;
+      delete m.correlationId;
+    }
+    body.metadata = m;
+  }
+  return body;
+}
+function validateParams(params, warn) {
+  if (!params.agentId) {
+    throw new ZihinAgentError("config", "agentId is required.");
+  }
+  if (!params.message && !(params.attachments && params.attachments.length)) {
+    throw new ZihinAgentError("config", "Either `message` or `attachments` is required.");
+  }
+  if (params.message) {
+    const sizeCheck = validatePromptSize(params.message);
+    if (!sizeCheck.valid) {
+      throw new ZihinAgentError("config", sizeCheck.error || "Message too large.");
+    }
+  }
+  validateStructuredInput(params);
+  warnDeprecatedOptions(params, warn);
+  if (params.options?.timeoutMs !== void 0) {
+    normalizeTimeoutMs(params.options.timeoutMs, "options.timeoutMs");
+  }
+  for (const att of params.attachments ?? []) {
+    const urlCheck = validateBaseUrl(att.url, { allowCustomDomains: true });
+    if (!urlCheck.valid) {
+      throw new ZihinAgentError("config", `Invalid attachment URL: ${urlCheck.error}`);
+    }
+  }
+}
+function warnDeprecatedOptions(params, warn) {
+  const o = params.options;
+  if (!o) return;
+  if (o.jitMode !== void 0) {
+    warnDeprecatedOnce(
+      "ZIHIN_DEP001",
+      "`options.jitMode` is deprecated and has no effect (the server discontinued it). Remove it; it will be dropped from the SDK in 1.0.",
+      warn
+    );
+  }
+  if (o.temperature !== void 0 || o.maxTokens !== void 0) {
+    warnDeprecatedOnce(
+      "ZIHIN_DEP002",
+      "`options.temperature`/`options.maxTokens` have no effect: the agent's own configuration (`llm_config`) decides them \u2014 change it in the Zihin console or with `update_agent`. They will be dropped from the SDK in 1.0.",
+      warn
+    );
+  }
+}
+var MAX_FIELDS = 50;
+var MAX_VALUE_CHARS = 2e3;
+var MAX_TOTAL_CHARS = { context: 2e3, bindings: 16e3 };
+var MAX_SESSION_FROM_FIELDS = 5;
+var FIELD_NAME_RE = /^[A-Za-z_][A-Za-z0-9_-]{0,63}$/;
+var PROTOTYPE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var MAX_CONSUMER_KEY_CHARS = 200;
+var MAX_CONSUMER_NAME_CHARS = 255;
+var MAX_CLIENT_BLOCKS = 10;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function snapshotStructuredInput(params) {
+  const snap = (v) => isPlainObject(v) ? Object.fromEntries(Object.entries(v).filter(([, x]) => x !== void 0)) : v;
+  return {
+    ...params,
+    ...normalizeConsumer(params),
+    context: snap(params.context),
+    bindings: snap(params.bindings),
+    sessionFrom: Array.isArray(params.sessionFrom) ? [...params.sessionFrom] : params.sessionFrom,
+    capabilities: isPlainObject(params.capabilities) ? {
+      ...params.capabilities,
+      blocks: Array.isArray(params.capabilities.blocks) ? [...params.capabilities.blocks] : params.capabilities.blocks
+    } : params.capabilities
+  };
+}
+function normalizeConsumer(params) {
+  const c = params.consumer;
+  if (c === void 0) return {};
+  if (!isPlainObject(c)) {
+    throw new ZihinAgentError("config", "`consumer` must be an object: `{ key, name? }`.");
+  }
+  const key = c.key;
+  if (params.consumerKey !== void 0 && key !== void 0 && params.consumerKey !== key) {
+    throw new ZihinAgentError("config", "`consumerKey` and `consumer.key` differ \u2014 send only one of them.");
+  }
+  const resolved = key ?? params.consumerKey;
+  return {
+    consumerKey: resolved,
+    consumer: { key: resolved, ...c.name !== void 0 ? { name: c.name } : {} }
+  };
+}
+function isPlainObject(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+function isScalar(v) {
+  return v === null || typeof v === "string" || typeof v === "boolean" || typeof v === "number" && Number.isFinite(v);
+}
+function validateStructuredInput(params) {
+  if (params.clientMessageId !== void 0 && (typeof params.clientMessageId !== "string" || !UUID_RE.test(params.clientMessageId))) {
+    throw new ZihinAgentError("config", "`clientMessageId` must be a UUID (e.g. from `crypto.randomUUID()`).");
+  }
+  if (params.consumerKey !== void 0 && (typeof params.consumerKey !== "string" || !params.consumerKey.trim())) {
+    throw new ZihinAgentError("config", "`consumerKey` must be a non-empty string.");
+  }
+  if (typeof params.consumerKey === "string" && params.consumerKey.length > MAX_CONSUMER_KEY_CHARS) {
+    throw new ZihinAgentError("config", `\`consumerKey\` is longer than ${MAX_CONSUMER_KEY_CHARS} characters.`);
+  }
+  if (params.consumer !== void 0) {
+    if (params.consumerKey === void 0) {
+      throw new ZihinAgentError("config", "`consumer.key` is required (the name has nothing to attach to without it).");
+    }
+    const n = params.consumer.name;
+    if (n !== void 0 && (typeof n !== "string" || !n.trim() || n.length > MAX_CONSUMER_NAME_CHARS)) {
+      throw new ZihinAgentError("config", `\`consumer.name\` must be a non-empty string of up to ${MAX_CONSUMER_NAME_CHARS} characters.`);
+    }
+  }
+  if (params.capabilities !== void 0) {
+    const blocks = isPlainObject(params.capabilities) ? params.capabilities.blocks : null;
+    if (blocks === null || blocks !== void 0 && (!Array.isArray(blocks) || blocks.length > MAX_CLIENT_BLOCKS || blocks.some((b) => typeof b !== "string"))) {
+      throw new ZihinAgentError(
+        "config",
+        `\`capabilities\` must be \`{ blocks: [...] }\` with up to ${MAX_CLIENT_BLOCKS} block names (e.g. \`['quick_replies']\`).`
+      );
+    }
+  }
+  for (const name of ["context", "bindings"]) {
+    const v = params[name];
+    if (v === void 0) continue;
+    if (!isPlainObject(v)) {
+      throw new ZihinAgentError("config", `\`${name}\` must be a flat plain object.`);
+    }
+    const entries = Object.entries(v);
+    if (entries.length > MAX_FIELDS) {
+      throw new ZihinAgentError("config", `\`${name}\` accepts at most ${MAX_FIELDS} fields.`);
+    }
+    for (const [k, val] of entries) {
+      if (!FIELD_NAME_RE.test(k) || PROTOTYPE_KEYS.has(k)) {
+        throw new ZihinAgentError(
+          "config",
+          `Invalid field name in \`${name}\`: use letters, digits, \`_\` or \`-\`, starting with a letter or \`_\` (max 64 characters; \`constructor\`, \`prototype\` and \`__proto__\` are not allowed).`
+        );
+      }
+      if (typeof val === "string" && val.length > MAX_VALUE_CHARS) {
+        throw new ZihinAgentError("config", `\`${name}.${k}\` is longer than ${MAX_VALUE_CHARS} characters.`);
+      }
+      if (!isScalar(val)) {
+        throw new ZihinAgentError(
+          "config",
+          `\`${name}.${k}\` must be a string, number, boolean or null \u2014 \`${name}\` is flat (no nested objects or arrays).`
+        );
+      }
+    }
+    if (JSON.stringify(v).length > MAX_TOTAL_CHARS[name]) {
+      throw new ZihinAgentError("config", `\`${name}\` is longer than ${MAX_TOTAL_CHARS[name]} characters in total (as JSON).`);
+    }
+  }
+  if (params.sessionFrom !== void 0) {
+    if (!Array.isArray(params.sessionFrom) || params.sessionFrom.length > MAX_SESSION_FROM_FIELDS || params.sessionFrom.some((f) => typeof f !== "string" || !FIELD_NAME_RE.test(f) || PROTOTYPE_KEYS.has(f))) {
+      throw new ZihinAgentError("config", `\`sessionFrom\` must be an array of up to ${MAX_SESSION_FROM_FIELDS} field names.`);
+    }
+    if (params.sessionFrom.length && params.sessionId) {
+      throw new ZihinAgentError("config", "Use either `sessionId` or `sessionFrom`, not both.");
+    }
+    const available = { ...params.context, ...params.bindings };
+    const has = (f) => Object.prototype.hasOwnProperty.call(available, f) && Boolean(available[f]);
+    if (params.sessionFrom.length && !params.sessionFrom.some(has)) {
+      throw new ZihinAgentError(
+        "config",
+        `\`sessionFrom\` names ${params.sessionFrom.map((f) => `"${f}"`).join(", ")}, but none of them has a value in \`context\` or \`bindings\`.`
+      );
+    }
+  }
+}
+function requestedInputFields(params) {
+  const out = [];
+  if (params.context) out.push("context");
+  if (params.bindings) out.push("bindings");
+  if (params.sessionFrom?.length) out.push("session_from");
+  if (params.clientMessageId) out.push("client_message_id");
+  return out;
+}
+function checkInputCapability(params, chunk) {
+  const requested = requestedInputFields(params);
+  const ignored = chunk?.ignoredFields ?? [];
+  const sent = [...requested, ...params.consumerKey ? ["consumer_key"] : []];
+  const blocking = ignored.filter(
+    (f) => f.reason !== "redacted" && sent.some((name) => f.field === name || f.field.startsWith(`${name}.`))
+  );
+  const tail = "the stream was closed to cancel the turn, but the message may already be recorded in the session.";
+  if (blocking.length) {
+    const shown = blocking.slice(0, 5);
+    const more = blocking.length > shown.length ? ` (+${blocking.length - shown.length} more)` : "";
+    const what = shown.map((f) => f.reason ? `\`${f.field}\` (${f.reason})` : `\`${f.field}\``).join(", ") + more;
+    const hint = blocking.some((f) => f.reason === "reserved_key") ? " Reserved keys are names the agent engine uses internally; rename them." : blocking.some((f) => f.reason === "requires_admin_api_key") ? " These fields only apply with an admin/owner API key." : "";
+    throw new ZihinAgentError("config", `The server ignored ${what}.${hint} The answer is not used: ${tail}`, {
+      requestId: chunk?.requestId
+    });
+  }
+  if (requested.length && chunk?.acceptedFields === void 0) {
+    throw new ZihinAgentError(
+      "config",
+      `This Zihin server does not support ${requested.map((f) => `\`${f}\``).join(", ")} on /stream yet (no \`accepted_fields\` in the stream metadata) \u2014 ${tail}`,
+      { requestId: chunk?.requestId }
+    );
+  }
+  const mustAccept = chunk?.acceptedFields !== void 0 && params.consumerKey ? [...requested, "consumer_key"] : requested;
+  const notAccepted = mustAccept.filter((f) => !chunk?.acceptedFields?.includes(f));
+  if (notAccepted.length) {
+    throw new ZihinAgentError(
+      "config",
+      `The server did not accept ${notAccepted.map((f) => `\`${f}\``).join(", ")} (missing from \`accepted_fields\`) \u2014 ${tail}`,
+      { requestId: chunk?.requestId }
+    );
+  }
+}
+var TURN_EVENTS = /* @__PURE__ */ new Set(["phase", "thinking", "tool", "action_proposed", "action_forwarded", "token", "response", "metrics", "done"]);
+async function* streamAgent(cfg, rawParams) {
+  const params = snapshotStructuredInput(rawParams);
+  validateParams(params, cfg.runtime.warn);
+  const callerTimeoutMs = params.options?.timeoutMs !== void 0 ? normalizeTimeoutMs(params.options.timeoutMs, "options.timeoutMs") : void 0;
+  const timeoutMs = callerTimeoutMs !== void 0 ? callerTimeoutMs + DEADLINE_GRACE_MS : resolveTimeout(cfg, "stream");
+  const reportedMs = callerTimeoutMs ?? timeoutMs;
+  const url = `${cfg.baseUrl}/api/v2/agents/${encodeURIComponent(params.agentId)}/stream`;
+  let needsCapability = requestedInputFields(params).length > 0 || !!params.consumerKey;
+  let gated = false;
+  const { response, deadline, endpoint } = await openStream({
+    url,
+    headers: buildHeaders(cfg.apiKey),
+    body: toJsonBody(buildRequestBody(params, callerTimeoutMs), "request body"),
+    timeoutMs,
+    reportedTimeoutMs: reportedMs,
+    maxRetries: cfg.maxRetries,
+    callerSignal: params.signal,
+    fetchImpl: cfg.fetchImpl,
+    runtime: cfg.runtime,
+    onRetry: cfg.onRetry,
+    // Retry do POST só ANTES dos headers chegarem. O que o torna seguro é a ordem do BE: o SSE faz
+    // `flushHeaders()` antes de reservar o id e antes de qualquer trabalho do turno, então falhar
+    // sem headers quase sempre significa que o handler nem começou. A chave cobre o resto: se o 1º
+    // POST chegou a rodar, o reenvio dá SESSION_BUSY (em voo) ou replay (COMPLETED/LENGTH). A chave
+    // NÃO protege turno cortado no meio: o BE cancela e libera o id, e o reenvio roda de novo com as
+    // tools — por isso o erro mid-stream sai `retryable: false`. Liga antes de ver `accepted_fields`
+    // (chega no `metadata`): contra BE antigo o retry pré-headers acontece sem a chave valer —
+    // aceitável pela mesma ordem (headers antes do trabalho), mas documentado no README.
+    // Resíduo não verificado: proxy que bufferiza headers e devolve 502/504 depois do BE já ter
+    // começado (X-Accel-Buffering: no torna isso improvável).
+    idempotent: !!params.clientMessageId
+  });
+  try {
+    if (!response.ok) {
+      let text = "";
+      try {
+        text = await response.text();
+      } catch {
+      }
+      throw errorFromResponse(response.status, parseBody(text), { endpoint });
+    }
+    const onAbortError = () => deadline.timedOut() ? new ZihinAgentError("timeout", `Stream timed out after ${reportedMs}ms.`, { endpoint }) : deadline.abortedByCaller() ? new ZihinAgentError("aborted", "Stream aborted by the caller.", { endpoint }) : new ZihinAgentError("network", "Stream connection interrupted.", { endpoint, retryable: false });
+    for await (const e of parseSse(response, {
+      signal: params.signal,
+      onAbortError,
+      maxEventBytes: cfg.maxStreamEventBytes,
+      maxTotalBytes: cfg.maxStreamTotalBytes
+    })) {
+      const chunk = mapEvent(e);
+      if (needsCapability) {
+        if (chunk.type === "metadata") checkInputCapability(params, chunk);
+        else if (chunk.type === "status" && chunk.phase === "GATED") gated = true;
+        else if (TURN_EVENTS.has(chunk.type) && !gated) checkInputCapability(params, void 0);
+        if (chunk.type === "metadata" || TURN_EVENTS.has(chunk.type) && !gated) needsCapability = false;
+      }
+      yield chunk;
+    }
+  } finally {
+    deadline.dispose();
+  }
+}
+function classifyStreamErrorKind(code, timedOut) {
+  if (timedOut === true) return "timeout";
+  if (code === "VALIDATION_ERROR") return "config";
+  const known = own(STREAM_ERROR_CODES, code);
+  if (known) return known.kind;
+  if (timedOut === false) return "server";
+  return /TIMEOUT/i.test(code) ? "timeout" : "server";
+}
+var STREAM_ERROR_CODES = {
+  SESSION_BUSY: {
+    kind: "blocked",
+    message: "Another turn is still running in this session (or the same clientMessageId is still in flight); retry after it finishes.",
+    retryable: true
+  },
+  IDEMPOTENCY_CONFLICT: {
+    kind: "config",
+    message: "This `clientMessageId` was already used with a different message \u2014 use a new UUID per message."
+  },
+  // `keepServerMessage`: a frase do BE diz o que foi e o que NÃO foi feito (tools que rodaram) —
+  // o integrador precisa dela para decidir se reenvia.
+  CONTEXT_LIMIT: {
+    kind: "blocked",
+    message: "The conversation gathered more context than the model can process; send a smaller request or start a new session.",
+    keepServerMessage: true
+  },
+  CONFLICT: {
+    kind: "blocked",
+    message: "The declared consumer identity does not match the one already bound to this session."
+  },
+  NOT_FOUND: {
+    kind: "not_found",
+    message: "Agent not found, inactive, or not accessible with this API key \u2014 check the agent ID and that the key belongs to the same Zihin workspace."
+  },
+  // Replay idempotente sem resposta recuperável. Pode persistir por 24 h (turno gravado sem
+  // mensagem do assistente): retentar com o MESMO id bate no mesmo erro, por isso não é
+  // retentável — o aviso diz a saída (novo `clientMessageId`).
+  SERVICE_UNAVAILABLE: {
+    kind: "server",
+    message: "This message was already answered, but the stored answer could not be read; resend with a new clientMessageId.",
+    retryable: false
+  },
+  // Defensivo: não há ponto de emissão in-stream observado no BE @ 9ec79cfc.
+  RATE_LIMIT_EXCEEDED: { kind: "rate_limit", retryable: true },
+  QUOTA_EXCEEDED: { kind: "quota_exceeded" },
+  TRIAL_EXPIRED: { kind: "trial_expired" },
+  NO_ACTIVE_SUBSCRIPTION: { kind: "no_subscription" }
+};
+function errorFromStreamChunk(chunk, ctx = {}) {
+  const code = chunk.code ?? "AGENT_ERROR";
+  const kind = classifyStreamErrorKind(code, chunk.timedOut);
+  const known = chunk.timedOut === true ? void 0 : own(STREAM_ERROR_CODES, code);
+  const serverMsg = chunk.message ? sanitizeApiError(chunk.message).message.replace(/<[^>]*>/g, "").slice(0, 300) : "";
+  const message = known?.message ? known.keepServerMessage && serverMsg ? `${known.message} Server: ${serverMsg}` : known.message : serverMsg || code;
+  return new ZihinAgentError(kind, message, {
+    code,
+    requestId: chunk.requestId,
+    executionId: safeId(ctx.executionId),
+    sessionId: safeId(ctx.sessionId),
+    retryable: known?.retryable ?? false
+  });
+}
+var FAILED_OUTCOMES = {
+  ERROR: { kind: "server", message: "The agent turn failed on the server; its text is the engine failure notice, not an answer." },
+  // `server`, não `aborted`: `aborted` é o cancelamento do PRÓPRIO chamador, que `onError` manda
+  // filtrar — um cancelamento feito pelo operador sumiria junto.
+  CANCELLED: { kind: "server", message: "The agent turn was cancelled on the server (by an operator or a platform guard)." },
+  // Modo processo drenando/encerrando; o motor retoma depois. Nenhum canal atual o produz.
+  SUSPENDED: { kind: "blocked", message: "The agent turn was suspended by the server and did not answer; retry later." },
+  BUDGET_EXCEEDED: { kind: "blocked", message: "The agent's spending cap was reached; raise the agent budget to keep invoking it." },
+  QUOTA_EXCEEDED: { kind: "quota_exceeded", message: "Your Zihin token quota is exhausted. Upgrade the plan or wait for the next cycle." },
+  SESSION_BUSY: {
+    kind: "blocked",
+    message: "Another turn is still running in this session; retry after it finishes.",
+    retryable: true
+  },
+  // Hoje a rota manda CONFLICT como `event: error` (não chega ao `done`); mapeado por defesa.
+  CONFLICT: {
+    kind: "blocked",
+    message: "The declared consumer identity does not match the one already bound to this session."
+  },
+  // O provedor do modelo recusou por política (BE `4cea8d53`, 08/10/2026). O `content` é um texto
+  // neutro FIXO da plataforma ("Não consigo ajudar com esse pedido…"), não uma resposta: o BE
+  // registra a execução como erro. Publicá-lo como resposta era a falha silenciosa da 0.6.
+  REFUSED: {
+    kind: "blocked",
+    message: "The model provider refused this request under its content policy; the agent did not answer."
+  },
+  // No `/stream` chega como `event: error` (ver STREAM_ERROR_CODES); no webhook sync e em
+  // backends futuros pode vir como desfecho.
+  CONTEXT_LIMIT: {
+    kind: "blocked",
+    message: "The conversation gathered more context than the model can process; send a smaller request or start a new session."
+  }
+};
+function errorFromOutcome(outcome, ctx = {}) {
+  const label = safeLabel(outcome);
+  if (!label) return void 0;
+  ctx = { ...ctx, executionId: safeId(ctx.executionId), sessionId: safeId(ctx.sessionId) };
+  if (label === "TIMEOUT") {
+    return new ZihinAgentError("timeout", "The agent turn timed out on the server.", { ...ctx, code: "TURN_TIMEOUT", retryable: false });
+  }
+  const failed = own(FAILED_OUTCOMES, label);
+  if (!failed) return void 0;
+  return new ZihinAgentError(failed.kind, failed.message, { ...ctx, code: label, retryable: failed.retryable ?? false });
+}
+var PAUSED_BLOCKS = /* @__PURE__ */ new Set(["agent_paused", "agent_archived"]);
+var ERROR_BLOCKS = {
+  ownership_denied: {
+    kind: "not_found",
+    message: "Session not found for this API key \u2014 start a new conversation (omit sessionId) instead of reusing this one."
+  },
+  session_load_failed: { kind: "blocked", message: "The server could not load this conversation right now; retry shortly.", retryable: true },
+  approval_resolve_failed: { kind: "blocked", message: "The server could not route the required approval right now; retry shortly.", retryable: true },
+  approval_no_approver: { kind: "blocked", message: "This action requires approval, but the approval policy has no approver configured." },
+  blocked_schedule: { kind: "blocked", message: "The agent is outside its allowed schedule (security policy)." },
+  owner_inactive: { kind: "blocked", message: "The agent's owner is inactive; the agent cannot be invoked." }
+};
+function own(table, key) {
+  return key !== void 0 && Object.prototype.hasOwnProperty.call(table, key) ? table[key] : void 0;
+}
+function errorFromDoneChunk(chunk, ctx = {}) {
+  const meta = { executionId: ctx.executionId, sessionId: ctx.sessionId };
+  const blockedReason = safeLabel(ctx.blocked);
+  if (chunk.outcome === "TIMEOUT" || chunk.timedOut === true) {
+    const clock = chunk.timeoutClock;
+    const what = clock === "turn" ? "the turn deadline" : clock === "first_signal" ? "the model provider did not start responding in time" : clock === "idle" ? "the model provider stream went silent" : clock === "call" ? "the model call took too long" : "a server-side clock";
+    return new ZihinAgentError("timeout", `The agent turn timed out (${what}).`, {
+      ...meta,
+      code: "TURN_TIMEOUT",
+      retryable: false,
+      timeoutClock: clock
+    });
+  }
+  if (chunk.outcome === "PAUSED" && blockedReason && PAUSED_BLOCKS.has(blockedReason)) {
+    return new ZihinAgentError("blocked", "The agent is paused or archived and did not answer.", {
+      ...meta,
+      code: "PAUSED",
+      retryable: false
+    });
+  }
+  if (chunk.outcome === "ERROR" && blockedReason) {
+    const gate = own(ERROR_BLOCKS, blockedReason);
+    return new ZihinAgentError(gate?.kind ?? "blocked", gate?.message ?? `The agent turn was blocked by the server (${blockedReason}).`, {
+      ...meta,
+      code: blockedReason.toUpperCase(),
+      retryable: gate?.retryable ?? false
+    });
+  }
+  const failed = own(FAILED_OUTCOMES, chunk.outcome);
+  if (!failed) return void 0;
+  return new ZihinAgentError(failed.kind, failed.message, {
+    ...meta,
+    code: chunk.outcome,
+    retryable: failed.retryable ?? false
+  });
+}
+async function invokeAgent(cfg, params) {
+  const raw = [];
+  const keepRaw = params.includeRaw === true;
+  let responseChunk;
+  let metricsChunk;
+  let metadataChunk;
+  let metadataSessionId;
+  let mintedSessionId;
+  let doneChunk;
+  let blocked;
+  let acceptedFields;
+  let ignoredFields;
+  let tokenBuffer = "";
+  for await (const chunk of streamAgent(cfg, params)) {
+    if (keepRaw) raw.push(chunk);
+    if (chunk.type === "error") {
+      throw errorFromStreamChunk(chunk, {
+        executionId: metadataChunk?.executionId,
+        sessionId: mintedSessionId ?? metadataSessionId ?? params.sessionId
+      });
+    }
+    if (chunk.type === "response") responseChunk = chunk;
+    else if (chunk.type === "metrics") metricsChunk = chunk;
+    else if (chunk.type === "token") tokenBuffer += chunk.content;
+    else if (chunk.type === "metadata") {
+      metadataChunk = chunk;
+      if (chunk.sessionId) metadataSessionId = chunk.sessionId;
+      acceptedFields = chunk.acceptedFields;
+      ignoredFields = chunk.ignoredFields;
+    } else if (chunk.type === "session" && chunk.sessionId) mintedSessionId = chunk.sessionId;
+    else if (chunk.type === "done") doneChunk = chunk;
+    else if (chunk.type === "status" && chunk.blocked) blocked = chunk.blocked;
+  }
+  const sessionId = mintedSessionId ?? responseChunk?.sessionId ?? metadataSessionId ?? params.sessionId;
+  const executionId = metadataChunk?.executionId ?? doneChunk?.executionId ?? responseChunk?.executionId ?? metricsChunk?.executionId;
+  const ids = {
+    clientMessageId: doneChunk?.clientMessageId ?? responseChunk?.clientMessageId ?? metadataChunk?.clientMessageId,
+    idempotentReplay: doneChunk?.idempotentReplay ?? responseChunk?.idempotentReplay ?? metadataChunk?.idempotentReplay,
+    userMessageId: doneChunk?.userMessageId ?? responseChunk?.userMessageId,
+    assistantMessageId: doneChunk?.assistantMessageId ?? responseChunk?.assistantMessageId
+  };
+  const outcomeError = doneChunk && errorFromDoneChunk(doneChunk, { executionId, sessionId, blocked });
+  if (outcomeError) throw outcomeError;
+  const replaySession = responseChunk?.sessionId ?? metadataSessionId;
+  if (ids.idempotentReplay && params.sessionId && replaySession && replaySession.toLowerCase() !== params.sessionId.toLowerCase()) {
+    throw new ZihinAgentError(
+      "config",
+      "This `clientMessageId` was already used in a different session: the server replayed that session's answer. Use a new UUID per message (never a fixed value).",
+      { code: "IDEMPOTENT_REPLAY_OTHER_SESSION", executionId, sessionId: params.sessionId, retryable: false }
+    );
+  }
+  const cleanEnd = doneChunk !== void 0;
+  if (!responseChunk) {
+    if (cleanEnd) {
+      throw new ZihinAgentError("protocol", "Stream ended (done) without a `response` event.");
+    }
+    if (tokenBuffer) {
+      return {
+        content: tokenBuffer,
+        contentSource: "tokens",
+        sessionId,
+        usage: metricsChunk?.usage,
+        model: metricsChunk?.model,
+        iterations: metricsChunk?.iterations,
+        executionTimeMs: metricsChunk?.executionTimeMs,
+        executionId,
+        ...ids,
+        acceptedFields,
+        ignoredFields,
+        raw
+      };
+    }
+    throw new ZihinAgentError("protocol", "Stream ended without a `response` event.");
+  }
+  return {
+    content: responseChunk.content,
+    contentSource: "response",
+    sessionId,
+    model: metricsChunk?.model,
+    usage: metricsChunk?.usage,
+    sources: responseChunk.sources,
+    blocks: responseChunk.blocks,
+    suggestions: responseChunk.suggestions,
+    gated: responseChunk.gated,
+    iterations: metricsChunk?.iterations,
+    executionTimeMs: metricsChunk?.executionTimeMs,
+    executionId,
+    ...ids,
+    outcome: doneChunk?.outcome,
+    truncated: doneChunk?.truncated,
+    finishReason: doneChunk?.finishReason,
+    acceptedFields,
+    ignoredFields,
+    raw
+  };
+}
+
+// src/tasks.ts
+var MAX_TASK_PAYLOAD_BYTES = 64 * 1024;
+var SCHEDULE_PAST_TOLERANCE_MS = 6e4;
+function envelope(json) {
+  const j = rec(json);
+  return { data: rec(j.data ?? j), meta: rec(j.meta) };
+}
+function toIso(value, label) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const d = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(d.getTime())) {
+    throw new ZihinAgentError("config", `${label} must be a valid ISO 8601 date (got ${JSON.stringify(value)}).`);
+  }
+  return d.toISOString();
+}
+function mapTask(raw) {
+  const t = rec(raw);
+  const status = str(t.status);
+  return {
+    id: str(t.id) ?? "",
+    agentId: str(t.agent_id),
+    title: str(t.title),
+    instruction: str(t.instruction),
+    status: status ?? "unknown",
+    // Mesma regra do Caminho B, e de propósito a MESMA função: status desconhecido conta como
+    // terminal (o polling para em vez de girar), status ausente não (não lemos o envelope).
+    terminal: status === void 0 ? false : isTerminalStatus(status),
+    scheduledFor: str(t.scheduled_for),
+    deadlineAt: str(t.deadline_at),
+    parentTaskId: str(t.parent_task_id),
+    rootTaskId: str(t.root_task_id),
+    sessionId: str(t.session_id),
+    createdAt: str(t.created_at),
+    updatedAt: str(t.updated_at),
+    raw
+  };
+}
+function mapExecution(raw) {
+  const e = rec(raw);
+  return {
+    id: str(e.id) ?? "",
+    status: str(e.status) ?? "unknown",
+    exitReason: str(e.exit_reason),
+    modelUsed: str(e.model_used),
+    totalCostUsd: num(e.total_cost_usd),
+    executionTimeMs: num(e.execution_time_ms),
+    iterations: num(e.iterations),
+    startedAt: str(e.started_at),
+    finishedAt: str(e.finished_at),
+    raw
+  };
+}
+async function delegateTask(cfg, params) {
+  if (!params.agentId) throw new ZihinAgentError("config", "agentId is required.");
+  if (!params.instruction) throw new ZihinAgentError("config", "instruction is required.");
+  const scheduledFor = toIso(params.scheduledFor, "scheduledFor");
+  const deadlineAt = toIso(params.deadlineAt, "deadlineAt");
+  if (scheduledFor && Date.parse(scheduledFor) < Date.now() - SCHEDULE_PAST_TOLERANCE_MS) {
+    throw new ZihinAgentError("config", "scheduledFor is in the past.");
+  }
+  if (deadlineAt && Date.parse(deadlineAt) <= Date.now() - SCHEDULE_PAST_TOLERANCE_MS) {
+    throw new ZihinAgentError("config", "deadlineAt must be in the future.");
+  }
+  if (scheduledFor && deadlineAt && Date.parse(deadlineAt) <= Date.parse(scheduledFor)) {
+    throw new ZihinAgentError("config", "deadlineAt must be after scheduledFor.");
+  }
+  if (params.payload !== void 0) {
+    if (typeof params.payload !== "object" || params.payload === null || Array.isArray(params.payload)) {
+      throw new ZihinAgentError("config", "payload must be an object.");
+    }
+    const bytes = toJsonBody(params.payload, "payload").length;
+    if (bytes > MAX_TASK_PAYLOAD_BYTES) {
+      throw new ZihinAgentError(
+        "config",
+        `payload exceeds ${MAX_TASK_PAYLOAD_BYTES / 1024}KB (got ${Math.ceil(bytes / 1024)}KB).`
+      );
+    }
+  }
+  const body = {
+    agent_id: params.agentId,
+    instruction: params.instruction
+  };
+  if (params.title !== void 0) body.title = params.title;
+  if (params.payload !== void 0) body.payload = params.payload;
+  if (scheduledFor) body.scheduled_for = scheduledFor;
+  if (deadlineAt) body.deadline_at = deadlineAt;
+  if (params.retryPolicy !== void 0) body.retry_policy = params.retryPolicy;
+  if (params.notify !== void 0) body.notify = params.notify;
+  if (params.parentTaskId) body.parent_task_id = params.parentTaskId;
+  const json = await requestJson(cfg, {
+    method: "POST",
+    path: "/api/v1/tasks",
+    body,
+    // Criar uma task E dispará-la é efeito colateral: nunca repetir em erro de rede.
+    policy: "side-effecting",
+    signal: params.signal
+  });
+  const { data } = envelope(json);
+  const task = mapTask(data.task ?? data);
+  if (!task.id) {
+    throw new ZihinAgentError("protocol", "delegateTask: response has no task id.");
+  }
+  return task;
+}
+async function listTasks(cfg, params = {}) {
+  const qs = new URLSearchParams();
+  if (params.live) qs.set("live", "true");
+  if (params.status) qs.set("status", params.status);
+  if (params.agentId) qs.set("agent_id", params.agentId);
+  if (params.rootTaskId) qs.set("root_task_id", params.rootTaskId);
+  if (params.limit !== void 0) qs.set("limit", String(params.limit));
+  if (params.offset !== void 0) qs.set("offset", String(params.offset));
+  const query = qs.toString();
+  const json = await requestJson(cfg, {
+    method: "GET",
+    path: `/api/v1/tasks${query ? `?${query}` : ""}`,
+    policy: "idempotent",
+    signal: params.signal
+  });
+  const { data, meta } = envelope(json);
+  const items = Array.isArray(data.items) ? data.items : [];
+  return {
+    items: items.map(mapTask),
+    // ⚠️ `total` vive em `meta`, não no topo — o envelope novo aninhou os campos de paginação.
+    total: num(meta.total),
+    raw: json
+  };
+}
+async function getTask(cfg, params) {
+  if (!params.taskId) throw new ZihinAgentError("config", "taskId is required.");
+  const json = await requestJson(cfg, {
+    method: "GET",
+    path: `/api/v1/tasks/${encodeURIComponent(params.taskId)}`,
+    policy: "idempotent",
+    signal: params.signal
+  });
+  const { data } = envelope(json);
+  const taskRaw = data.task ?? (str(rec(data).id) ? data : void 0);
+  if (!taskRaw || !str(rec(taskRaw).id)) {
+    throw new ZihinAgentError("protocol", "getTask: response has no task.");
+  }
+  const executions = Array.isArray(data.executions) ? data.executions : [];
+  const children = Array.isArray(data.children) ? data.children : [];
+  return {
+    task: mapTask(taskRaw),
+    executions: executions.map(mapExecution),
+    children: children.map(mapTask),
+    approvals: Array.isArray(data.approvals) ? data.approvals : [],
+    raw: json
+  };
+}
+async function cancelTask(cfg, params) {
+  if (!params.taskId) throw new ZihinAgentError("config", "taskId is required.");
+  const json = await requestJson(cfg, {
+    method: "POST",
+    path: `/api/v1/tasks/${encodeURIComponent(params.taskId)}/cancel`,
+    body: params.reason ? { reason: params.reason } : {},
+    // Cancelar é side-effecting; repetir num socket caído bateria em 409 e confundiria o chamador.
+    policy: "side-effecting",
+    signal: params.signal
+  });
+  const { data } = envelope(json);
+  const taskRaw = data.task ?? (str(rec(data).id) ? data : void 0);
+  if (!taskRaw || !str(rec(taskRaw).id)) {
+    throw new ZihinAgentError("protocol", "cancelTask: response has no task.");
+  }
+  return {
+    task: mapTask(taskRaw),
+    aborted: data.aborted === true,
+    raw: json
+  };
+}
+
+// src/triggers.ts
+function queryExtractionBody(extraction, queryField) {
+  if (!extraction) return { mode: "field", field: queryField ?? "message" };
+  switch (extraction.mode) {
+    case "field":
+      if (!extraction.field) {
+        throw new ZihinAgentError("config", 'queryExtraction.field is required for mode "field".');
+      }
+      return { mode: "field", field: extraction.field };
+    case "template":
+      if (!extraction.template) {
+        throw new ZihinAgentError("config", 'queryExtraction.template is required for mode "template".');
+      }
+      return { mode: "template", template: extraction.template };
+    case "full_body":
+      return { mode: "full_body" };
+    default:
+      throw new ZihinAgentError("config", "Unknown queryExtraction.mode (use field|template|full_body).");
+  }
+}
+async function createTrigger(cfg, params) {
+  if (!params.agentId) throw new ZihinAgentError("config", "agentId is required.");
+  if (!params.name) throw new ZihinAgentError("config", "name is required.");
+  const mode = params.mode ?? "async";
+  if (mode === "async" && !params.callbackUrl) {
+    throw new ZihinAgentError("config", "callbackUrl is required for async triggers.");
+  }
+  if (params.callbackUrl) {
+    const cb = validateBaseUrl(params.callbackUrl, { allowCustomDomains: true });
+    if (!cb.valid) {
+      throw new ZihinAgentError("config", `Invalid callbackUrl: ${cb.error}`);
+    }
+  }
+  if (params.responseTransform && !params.callbackUrl) {
+    throw new ZihinAgentError(
+      "config",
+      "responseTransform requires callbackUrl: the backend only reads it from trigger_config.execution.callback.response_transform, and a callback without a url is rejected."
+    );
+  }
+  const execution = { mode };
+  if (params.callbackUrl) {
+    execution.callback = {
+      url: params.callbackUrl,
+      method: params.callbackMethod ?? "POST",
+      ...params.responseTransform ? { response_transform: { mode: params.responseTransform } } : {}
+    };
+  }
+  const body = {
+    agent_id: params.agentId,
+    name: params.name,
+    trigger_type: "webhook",
+    trigger_config: {
+      query_extraction: queryExtractionBody(params.queryExtraction, params.queryField),
+      auth: { type: params.dispatchAuth ?? "api_key" },
+      execution
+    }
+  };
+  const json = rec(
+    await requestJson(cfg, { method: "POST", path: "/api/triggers", body, policy: "side-effecting", signal: params.signal })
+  );
+  const data = rec(json.data);
+  const triggerId = str(data.id) ?? str(json.id);
+  const webhookUrl = str(json.webhook_url) ?? (triggerId ? `${cfg.baseUrl}/api/triggers/webhook/${triggerId}` : void 0);
+  if (!triggerId || !webhookUrl) {
+    throw new ZihinAgentError("protocol", "createTrigger: missing trigger id / webhook url in response.");
+  }
+  return { triggerId, webhookUrl };
+}
+async function dispatchAgent(cfg, params) {
+  if (!params.triggerId) throw new ZihinAgentError("config", "triggerId is required.");
+  const res = await requestBuffered({
+    method: "POST",
+    url: `${cfg.baseUrl}/api/triggers/webhook/${encodeURIComponent(params.triggerId)}`,
+    headers: buildHeaders(cfg.apiKey),
+    body: toJsonBody(params.payload ?? {}, "payload"),
+    timeoutMs: resolveTimeout(cfg, "dispatch"),
+    maxRetries: cfg.maxRetries,
+    policy: "side-effecting",
+    // S1: nunca duplica disparo por erro de rede
+    callerSignal: params.signal,
+    fetchImpl: cfg.fetchImpl,
+    runtime: cfg.runtime,
+    onRetry: cfg.onRetry
+  });
+  if (!res.ok) {
+    throw errorFromResponse(res.status, parseBody(res.text), { endpoint: res.endpoint, attempts: res.attempts });
+  }
+  const json = parseBody(res.text);
+  const j = rec(json);
+  const preTurnOutcome = safeLabel(j.outcome);
+  if (j.success === false && preTurnOutcome && preTurnOutcome !== "ERROR") {
+    const classified = errorFromOutcome(preTurnOutcome, {
+      status: res.status,
+      endpoint: res.endpoint,
+      attempts: res.attempts,
+      executionId: safeId(j.execution_id)
+    });
+    if (classified) throw classified;
+  }
+  if (j.success === false) {
+    const detail = sanitizeApiError(str(j.error) ?? "").message;
+    throw new ZihinAgentError("server", detail || "The agent run failed.", {
+      status: res.status,
+      endpoint: res.endpoint,
+      attempts: res.attempts,
+      executionId: safeId(j.execution_id),
+      // Não é transitório: o turno rodou e falhou. Repetir gastaria outra execução.
+      retryable: false
+    });
+  }
+  const outcomeError = errorFromOutcome(str(j.outcome), {
+    status: res.status,
+    endpoint: res.endpoint,
+    attempts: res.attempts,
+    executionId: safeId(j.execution_id)
+  });
+  if (outcomeError) throw outcomeError;
+  return {
+    accepted: true,
+    outcome: safeLabel(j.outcome),
+    triggerId: str(j.trigger_id) ?? params.triggerId,
+    agentId: str(j.agent_id),
+    executionId: safeId(j.execution_id),
+    agentResponse: str(j.agent_response),
+    usage: parseUsage(j.usage),
+    iterations: num(j.iterations),
+    latencyMs: num(j.latency_ms),
+    // Qual texto o BE extraiu do payload — é o campo que denuncia um `query_extraction` mal
+    // configurado (mensagem vazia, ou o payload inteiro serializado virando a pergunta).
+    queryExtracted: str(j.query_extracted),
+    raw: json
+  };
+}
+function webhookUrlFor(cfg, t) {
+  if (str(t.webhook_url)) return str(t.webhook_url);
+  const id = str(t.id);
+  return t.trigger_type === "webhook" && id ? `${cfg.baseUrl}/api/triggers/webhook/${id}` : void 0;
+}
+function mapTriggerInfo(cfg, raw) {
+  const t = rec(raw);
+  return {
+    id: str(t.id) ?? "",
+    agentId: str(t.agent_id),
+    name: str(t.name),
+    description: str(t.description),
+    triggerType: str(t.trigger_type),
+    enabled: typeof t.enabled === "boolean" ? t.enabled : void 0,
+    triggerCount: num(t.trigger_count),
+    lastError: str(t.last_error),
+    webhookUrl: webhookUrlFor(cfg, t)
+  };
+}
+async function listTriggers(cfg, params = {}) {
+  const qs = new URLSearchParams();
+  if (params.agentId) qs.set("agentId", params.agentId);
+  if (params.triggerType) qs.set("triggerType", params.triggerType);
+  if (params.enabledOnly) qs.set("enabledOnly", "true");
+  const query = qs.toString();
+  const path = `/api/triggers${query ? `?${query}` : ""}`;
+  const json = await requestJson(cfg, { method: "GET", path, policy: "idempotent", signal: params.signal });
+  const list = Array.isArray(json) ? json : Array.isArray(rec(json).data) ? rec(json).data : [];
+  return list.map((t) => mapTriggerInfo(cfg, t));
+}
+async function getTrigger(cfg, params) {
+  if (!params.triggerId) throw new ZihinAgentError("config", "triggerId is required.");
+  const json = await requestJson(cfg, {
+    method: "GET",
+    path: `/api/triggers/${encodeURIComponent(params.triggerId)}`,
+    policy: "idempotent",
+    signal: params.signal
+  });
+  return mapTriggerInfo(cfg, rec(json).data ?? json);
+}
+async function updateTrigger(cfg, params) {
+  if (!params.triggerId) throw new ZihinAgentError("config", "triggerId is required.");
+  if (params.callbackUrl) {
+    const cb = validateBaseUrl(params.callbackUrl, { allowCustomDomains: true });
+    if (!cb.valid) {
+      throw new ZihinAgentError("config", `Invalid callbackUrl: ${cb.error}`);
+    }
+  }
+  const body = {};
+  if (params.name !== void 0) body.name = params.name;
+  if (params.description !== void 0) body.description = params.description;
+  if (params.enabled !== void 0) body.enabled = params.enabled;
+  const touchesConfig = params.queryExtraction !== void 0 || params.callbackUrl !== void 0 || params.callbackMethod !== void 0 || params.responseTransform !== void 0 || params.mode !== void 0;
+  if (touchesConfig) {
+    const path = `/api/triggers/${encodeURIComponent(params.triggerId)}`;
+    const currentJson = rec(
+      await requestJson(cfg, { method: "GET", path, policy: "idempotent", signal: params.signal })
+    );
+    const current = rec(currentJson.data ?? currentJson);
+    if (!current.trigger_config || typeof current.trigger_config !== "object" || Object.keys(rec(current.trigger_config)).length === 0) {
+      throw new ZihinAgentError(
+        "protocol",
+        "updateTrigger: current trigger_config unavailable \u2014 refusing to overwrite it partially."
+      );
+    }
+    const config = rec(current.trigger_config);
+    const merged = { ...config };
+    if (params.queryExtraction !== void 0) {
+      merged.query_extraction = queryExtractionBody(params.queryExtraction, void 0);
+    }
+    const touchesCallback = params.callbackUrl !== void 0 || params.callbackMethod !== void 0 || params.responseTransform !== void 0;
+    if (params.mode !== void 0 || touchesCallback) {
+      const execution = rec(config.execution);
+      const callback = rec(execution.callback);
+      const newExecution = { ...execution };
+      if (params.mode !== void 0) newExecution.mode = params.mode;
+      if (touchesCallback) {
+        const url = params.callbackUrl ?? str(callback.url);
+        if (!url) {
+          throw new ZihinAgentError(
+            "config",
+            params.responseTransform ? "responseTransform requires a callback: the backend only reads it from trigger_config.execution.callback.response_transform, and a callback without a url is rejected." : "callbackUrl is required: this trigger has no callback configured yet."
+          );
+        }
+        newExecution.callback = {
+          // Preserva o callback atual: trocar só a URL não pode apagar auth/headers/
+          // body_template/content_type/response_transform. Antes este objeto era
+          // SUBSTITUÍDO por { url, method } — a mesma perda silenciosa que o merge de
+          // trigger_config acima existe para evitar, um nível mais fundo.
+          ...callback,
+          url,
+          method: params.callbackMethod ?? str(callback.method) ?? "POST",
+          ...params.responseTransform ? {
+            response_transform: {
+              ...rec(callback.response_transform),
+              mode: params.responseTransform
+            }
+          } : {}
+        };
+      }
+      if (newExecution.mode === "async" && !rec(newExecution.callback).url) {
+        throw new ZihinAgentError("config", "callbackUrl is required for async triggers.");
+      }
+      merged.execution = newExecution;
+    }
+    body.trigger_config = merged;
+  }
+  if (Object.keys(body).length === 0) {
+    throw new ZihinAgentError("config", "updateTrigger: no fields to update.");
+  }
+  const json = await requestJson(cfg, {
+    method: "PATCH",
+    path: `/api/triggers/${encodeURIComponent(params.triggerId)}`,
+    body,
+    // PATCH aqui é replay-safe: reaplicar os mesmos valores produz o mesmo estado.
+    policy: "idempotent",
+    signal: params.signal
+  });
+  return mapTriggerInfo(cfg, rec(json).data ?? json);
+}
+async function deleteTrigger(cfg, params) {
+  if (!params.triggerId) throw new ZihinAgentError("config", "triggerId is required.");
+  const res = await requestBuffered({
+    method: "DELETE",
+    url: `${cfg.baseUrl}/api/triggers/${encodeURIComponent(params.triggerId)}`,
+    headers: buildHeaders(cfg.apiKey),
+    timeoutMs: resolveTimeout(cfg, "short"),
+    maxRetries: cfg.maxRetries,
+    policy: "idempotent",
+    // DELETE é idempotente
+    callerSignal: params.signal,
+    fetchImpl: cfg.fetchImpl,
+    runtime: cfg.runtime,
+    onRetry: cfg.onRetry
+  });
+  if (!res.ok) {
+    throw errorFromResponse(res.status, parseBody(res.text), { endpoint: res.endpoint, attempts: res.attempts });
+  }
+  const j = rec(parseBody(res.text));
+  return { deleted: j.deleted === true || res.status === 200 };
+}
+async function findOrCreateTrigger(cfg, params) {
+  if (!params.agentId) throw new ZihinAgentError("config", "agentId is required.");
+  if (!params.name) throw new ZihinAgentError("config", "name is required.");
+  const existing = await listTriggers(cfg, { agentId: params.agentId, signal: params.signal });
+  const match = existing.find((t) => t.name === params.name);
+  if (match && match.id) {
+    const webhookUrl = match.webhookUrl ?? `${cfg.baseUrl}/api/triggers/webhook/${match.id}`;
+    return { triggerId: match.id, webhookUrl, created: false };
+  }
+  const ref = await createTrigger(cfg, params);
+  return { ...ref, created: true };
+}
+async function getExecution(cfg, params) {
+  if (!params.triggerId || !params.executionId) {
+    throw new ZihinAgentError("config", "triggerId and executionId are required.");
+  }
+  const path = `/api/triggers/${encodeURIComponent(params.triggerId)}/executions/${encodeURIComponent(
+    params.executionId
+  )}`;
+  const json = rec(await requestJson(cfg, { method: "GET", path, policy: "idempotent", signal: params.signal }));
+  const data = rec(json.data);
+  const exec = rec(data.execution ?? json.execution);
+  const metrics = rec(data.metrics ?? json.metrics);
+  const rawStatus = str(exec.status);
+  return {
+    executionId: str(exec.id) ?? params.executionId,
+    status: rawStatus ?? "unknown",
+    terminal: rawStatus === void 0 ? false : isTerminalStatus(rawStatus),
+    startedAt: str(exec.started_at),
+    finishedAt: str(exec.finished_at),
+    executionTimeMs: num(exec.execution_time_ms),
+    usage: parseUsage(metrics.usage ?? metrics) ?? parseUsage(exec.usage),
+    result: str(exec.agent_response) ?? str(exec.result),
+    raw: json
+  };
+}
+
+// src/client.ts
+var ZihinAgentClient = class {
+  constructor(config) {
+    this.cfg = resolveConfig(config);
+  }
+  /** Base URL efetiva (após validação SSRF). */
+  get baseUrl() {
+    return this.cfg.baseUrl;
+  }
+  /** Notifica `config.onError` (falha definitiva); o callback nunca derruba o fluxo. */
+  report(err) {
+    if (this.cfg.onError && err instanceof ZihinAgentError) {
+      try {
+        this.cfg.onError(err);
+      } catch {
+      }
+    }
+  }
+  guard(p) {
+    return p.catch((err) => {
+      this.report(err);
+      throw err;
+    });
+  }
+  // ---- Caminho A: direto (SSE) ----
+  /** Invoca o agente e retorna o resultado final consolidado (response + metrics). */
+  invokeAgent(params) {
+    return this.guard(invokeAgent(this.cfg, params));
+  }
+  /** Emite deltas ao vivo do agente (async iterator). */
+  async *streamAgent(params) {
+    try {
+      yield* streamAgent(this.cfg, params);
+    } catch (err) {
+      this.report(err);
+      throw err;
+    }
+  }
+  // ---- Caminho B: triggers (async/callback) ----
+  /** Provisiona (1x) um trigger de webhook ligado a um agente. */
+  createTrigger(params) {
+    return this.guard(createTrigger(this.cfg, params));
+  }
+  /** Reaproveita (por agente+nome) ou cria um trigger — evita duplicação. */
+  findOrCreateTrigger(params) {
+    return this.guard(findOrCreateTrigger(this.cfg, params));
+  }
+  /** Lista os triggers do tenant (filtros opcionais). */
+  listTriggers(params = {}) {
+    return this.guard(listTriggers(this.cfg, params));
+  }
+  /** Obtém um trigger pelo id (inclui webhookUrl). */
+  getTrigger(params) {
+    return this.guard(getTrigger(this.cfg, params));
+  }
+  /** Atualiza um trigger (name/description/enabled/extração/callback) via PATCH. */
+  updateTrigger(params) {
+    return this.guard(updateTrigger(this.cfg, params));
+  }
+  /** Remove um trigger (requer key admin/owner). */
+  deleteTrigger(params) {
+    return this.guard(deleteTrigger(this.cfg, params));
+  }
+  /** Dispara um trigger: 202 (async) ou JSON imediato (sync). */
+  dispatchAgent(params) {
+    return this.guard(dispatchAgent(this.cfg, params));
+  }
+  /** Consulta o resultado de uma execução disparada por trigger (polling). */
+  getExecution(params) {
+    return this.guard(getExecution(this.cfg, params));
+  }
+  // ---- Caminho C: tasks (delegação assíncrona durável) ----
+  /**
+   * Delega uma tarefa a um agente (requer key owner/admin). Sem `scheduledFor`, o BE dispara na
+   * hora fora do request e devolve só o handle — acompanhe com `getTask`.
+   */
+  delegateTask(params) {
+    return this.guard(delegateTask(this.cfg, params));
+  }
+  /** Board de tasks do tenant (requer key owner/admin/editor). */
+  listTasks(params = {}) {
+    return this.guard(listTasks(this.cfg, params));
+  }
+  /** Dossiê de uma task: task + execuções + filhos + aprovações. */
+  getTask(params) {
+    return this.guard(getTask(this.cfg, params));
+  }
+  /** Cancela uma task (requer key owner/admin); derruba o turno em voo, se houver. */
+  cancelTask(params) {
+    return this.guard(cancelTask(this.cfg, params));
+  }
+  // ---- Auxiliar ----
+  /** Lista os agentes do tenant (dropdown). */
+  listAgents(opts = {}) {
+    return this.guard(listAgents(this.cfg, opts));
+  }
+};
+function createClient(config) {
+  return new ZihinAgentClient(config);
+}
+
+// src/signing.ts
+function loadNodeCrypto() {
+  const proc = globalThis.process;
+  if (typeof proc?.getBuiltinModule === "function") {
+    return proc.getBuiltinModule("node:crypto");
+  }
+  try {
+    return __require("crypto");
+  } catch {
+    throw new ZihinAgentError(
+      "config",
+      "signRequest requires Node.js crypto, unavailable in this runtime (the ESM build needs Node >=20.16)."
+    );
+  }
+}
+function signRequest(payload, secretKey, timestamp) {
+  const { createHmac, randomBytes } = loadNodeCrypto();
+  const ts = timestamp || Date.now();
+  const nonce = randomBytes(16).toString("hex");
+  const message = `${ts}.${nonce}.${payload}`;
+  const signature = createHmac("sha256", secretKey).update(message).digest("hex");
+  return {
+    "X-Zihin-Signature": `sha256=${signature}`,
+    "X-Zihin-Timestamp": ts.toString(),
+    "X-Zihin-Nonce": nonce
+  };
+}
+
+export {
+  validateBaseUrl,
+  DEFAULT_LIMITS,
+  validatePromptSize,
+  sanitizeApiError,
+  validateApiKeyFormat,
+  ZihinAgentError,
+  isCommercialBlock,
+  OPERATION_TIMEOUT_MS,
+  DEADLINE_GRACE_MS,
+  classifyStreamErrorKind,
+  errorFromStreamChunk,
+  errorFromOutcome,
+  errorFromDoneChunk,
+  MAX_TASK_PAYLOAD_BYTES,
+  ZihinAgentClient,
+  createClient,
+  signRequest
+};