@pushary/agent-hooks 0.28.1 → 0.28.2

package/dist/chunk-2Q6XPZ4Q.js

@@ -1,395 +0,0 @@
-import {
-  DEFAULT_SESSION,
-  cancelQuestion,
-  deriveReceiptMeta,
-  describeToolCall,
-  fetchModeState,
-  getMachineId,
-  isDefaultSession,
-  isPolicyConfig,
-  isToolResultError,
-  listPendingQuestions,
-  removePendingQuestion,
-  removePendingSession,
-  resolvePolicy
-} from "./chunk-GTJGZBTQ.js";
-import {
-  withRetry
-} from "./chunk-DWED7BS3.js";
-import {
-  getApiKey,
-  getBaseUrl
-} from "./chunk-NKXSILEW.js";
-
-// src/codex-adapter.ts
-var CODEX_AGENT = { type: "codex", label: "Codex" };
-var codexAllow = () => ({ kind: "allow" });
-var codexDeny = (reason) => ({ kind: "deny", reason });
-var codexPass = () => ({ kind: "pass" });
-var toCodexWire = (event, decision) => {
-  if (event === "PermissionRequest") {
-    if (decision.kind === "allow") {
-      return {
-        hookSpecificOutput: {
-          hookEventName: "PermissionRequest",
-          decision: { behavior: "allow" }
-        }
-      };
-    }
-    if (decision.kind === "deny") {
-      return {
-        hookSpecificOutput: {
-          hookEventName: "PermissionRequest",
-          decision: { behavior: "deny", message: decision.reason }
-        }
-      };
-    }
-    return null;
-  }
-  if (event === "PreToolUse" && decision.kind === "deny") {
-    return {
-      hookSpecificOutput: {
-        hookEventName: "PreToolUse",
-        permissionDecision: "deny",
-        permissionDecisionReason: decision.reason
-      }
-    };
-  }
-  return null;
-};
-var parseApplyPatchFiles = (command) => {
-  if (typeof command !== "string") return [];
-  const files = [];
-  for (const line of command.split("\n")) {
-    const match = line.match(/^\*\*\*\s+(?:Add|Update|Delete) File:\s+(.+?)\s*$/);
-    if (match) files.push(match[1]);
-  }
-  return files;
-};
-var toPolicyLookup = (toolName, toolInput) => {
-  if (toolName !== "apply_patch") return { tool: toolName, input: toolInput };
-  const command = toolInput.command;
-  const [fromPatch] = parseApplyPatchFiles(command);
-  const filePath = fromPatch ?? (typeof command === "string" && command.trim() && !command.includes("\n") && !command.includes("***") ? command.trim() : void 0);
-  return {
-    tool: "Edit",
-    input: filePath ? { file_path: filePath } : {}
-  };
-};
-var permissionTimeoutDecision = (timeoutAction) => {
-  if (timeoutAction === "approve") return codexAllow();
-  if (timeoutAction === "deny") return codexDeny("No response within timeout");
-  return codexPass();
-};
-var preToolUseTimeoutDecision = (timeoutAction, denyReason = "No response within timeout") => timeoutAction === "deny" ? codexDeny(denyReason) : codexPass();
-
-// src/usage.ts
-import { closeSync, mkdirSync, openSync, readFileSync, readSync, statSync, writeFileSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-var DEFAULT_PRICES = [
-  { match: "opus-4-1", in: 15, out: 75 },
-  { match: "opus-4-0", in: 15, out: 75 },
-  { match: "3-opus", in: 15, out: 75 },
-  { match: "opus", in: 5, out: 25 },
-  { match: "haiku", in: 1, out: 5 },
-  { match: "sonnet", in: 3, out: 15 }
-];
-var FALLBACK_PRICE = { match: "", in: 3, out: 15 };
-var CACHE_WRITE_MULTIPLIER = 1.25;
-var CACHE_READ_MULTIPLIER = 0.1;
-var RECENT_ID_LIMIT = 200;
-var READ_CHUNK_BYTES = 1024 * 1024;
-var isModelPrice = (value) => {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value;
-  return typeof candidate.match === "string" && typeof candidate.in === "number" && typeof candidate.out === "number";
-};
-var priceTable = () => {
-  const raw = process.env.PUSHARY_MODEL_PRICING?.trim();
-  if (!raw) return DEFAULT_PRICES;
-  try {
-    const parsed = JSON.parse(raw);
-    if (Array.isArray(parsed) && parsed.length > 0 && parsed.every(isModelPrice)) return parsed;
-  } catch {
-  }
-  return DEFAULT_PRICES;
-};
-var estimateCostUsd = (usage, model) => {
-  const price = priceTable().find((p) => model.includes(p.match)) ?? FALLBACK_PRICE;
-  const perTokenIn = price.in / 1e6;
-  const perTokenOut = price.out / 1e6;
-  return usage.inputTokens * perTokenIn + usage.outputTokens * perTokenOut + usage.cacheCreationTokens * perTokenIn * CACHE_WRITE_MULTIPLIER + usage.cacheReadTokens * perTokenIn * CACHE_READ_MULTIPLIER;
-};
-var stateDir = () => process.env.PUSHARY_USAGE_DIR?.trim() || join(tmpdir(), "pushary-usage");
-var stateFile = (sessionId) => join(stateDir(), sessionId.replace(/[^a-zA-Z0-9_-]/g, "_"));
-var emptyState = () => ({ offset: 0, tokensIn: 0, tokensOut: 0, costUsd: 0, recentIds: [] });
-var readState = (path) => {
-  try {
-    const parsed = JSON.parse(readFileSync(path, "utf-8"));
-    if (typeof parsed.offset === "number" && parsed.offset >= 0 && typeof parsed.tokensIn === "number" && typeof parsed.tokensOut === "number" && typeof parsed.costUsd === "number" && Array.isArray(parsed.recentIds)) {
-      return {
-        offset: parsed.offset,
-        tokensIn: parsed.tokensIn,
-        tokensOut: parsed.tokensOut,
-        costUsd: parsed.costUsd,
-        recentIds: parsed.recentIds.filter((id) => typeof id === "string")
-      };
-    }
-  } catch {
-  }
-  return emptyState();
-};
-var readRange = (path, start, end) => {
-  const fd = openSync(path, "r");
-  try {
-    const chunks = [];
-    let position = start;
-    while (position < end) {
-      const length = Math.min(READ_CHUNK_BYTES, end - position);
-      const buffer = Buffer.alloc(length);
-      const bytesRead = readSync(fd, buffer, 0, length, position);
-      if (bytesRead <= 0) break;
-      chunks.push(buffer.subarray(0, bytesRead));
-      position += bytesRead;
-    }
-    return Buffer.concat(chunks);
-  } finally {
-    closeSync(fd);
-  }
-};
-var toCount = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
-var applyLine = (state, line) => {
-  let parsed;
-  try {
-    parsed = JSON.parse(line);
-  } catch {
-    return 0;
-  }
-  if (parsed.type !== "assistant") return 0;
-  const usage = parsed.message?.usage;
-  if (!usage || typeof usage !== "object") return 0;
-  const model = typeof parsed.message?.model === "string" ? parsed.message.model : "";
-  if (model.includes("<synthetic>")) return 0;
-  const id = typeof parsed.message?.id === "string" ? parsed.message.id : null;
-  if (id) {
-    if (state.recentIds.includes(id)) return 0;
-    state.recentIds.push(id);
-    if (state.recentIds.length > RECENT_ID_LIMIT) state.recentIds.splice(0, state.recentIds.length - RECENT_ID_LIMIT);
-  }
-  const messageUsage = {
-    inputTokens: toCount(usage.input_tokens),
-    outputTokens: toCount(usage.output_tokens),
-    cacheCreationTokens: toCount(usage.cache_creation_input_tokens),
-    cacheReadTokens: toCount(usage.cache_read_input_tokens)
-  };
-  const cost = estimateCostUsd(messageUsage, model);
-  state.tokensIn += messageUsage.inputTokens + messageUsage.cacheCreationTokens + messageUsage.cacheReadTokens;
-  state.tokensOut += messageUsage.outputTokens;
-  state.costUsd += cost;
-  return cost;
-};
-var readNewUsage = (transcriptPath, sessionId) => {
-  try {
-    const size = statSync(transcriptPath).size;
-    const path = stateFile(sessionId);
-    let state = readState(path);
-    if (size < state.offset) state = { ...emptyState(), recentIds: state.recentIds };
-    let deltaUsd = 0;
-    if (size > state.offset) {
-      const buffer = readRange(transcriptPath, state.offset, size);
-      const lastNewline = buffer.lastIndexOf(10);
-      if (lastNewline >= 0) {
-        const complete = buffer.subarray(0, lastNewline + 1);
-        for (const line of complete.toString("utf-8").split("\n")) {
-          if (line.trim()) deltaUsd += applyLine(state, line);
-        }
-        state.offset += lastNewline + 1;
-      }
-    }
-    mkdirSync(stateDir(), { recursive: true });
-    writeFileSync(path, JSON.stringify(state), "utf-8");
-    if (state.tokensIn === 0 && state.tokensOut === 0) return null;
-    return {
-      tokensIn: state.tokensIn,
-      tokensOut: state.tokensOut,
-      costUsd: state.costUsd,
-      deltaUsd
-    };
-  } catch {
-    return null;
-  }
-};
-
-// src/events.ts
-import { basename, join as join2 } from "path";
-import { createHash } from "crypto";
-import { existsSync, readFileSync as readFileSync2 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-var cleanupPendingQuestions = async (sessionId) => {
-  try {
-    const files = listPendingQuestions(sessionId);
-    const apiKey = getApiKey();
-    for (const correlationId of files) {
-      try {
-        await cancelQuestion(apiKey, correlationId);
-      } catch {
-      }
-      removePendingQuestion(sessionId, correlationId);
-    }
-    if (!isDefaultSession(sessionId)) removePendingSession(sessionId);
-  } catch {
-  }
-};
-var CLAUDE_CODE_AGENT = { type: "claude_code", label: "Claude Code" };
-var POLICY_CACHE_TTL_MS = 5 * 60 * 1e3;
-var readFreshCachedPolicy = (apiKey) => {
-  const hash = createHash("sha256").update(apiKey).digest("hex").slice(0, 12);
-  const path = join2(tmpdir2(), `pushary-policy-${hash}.json`);
-  if (!existsSync(path)) return null;
-  const cached = JSON.parse(readFileSync2(path, "utf-8"));
-  if (!isPolicyConfig(cached)) return null;
-  if (!cached._cachedAt || Date.now() - cached._cachedAt >= POLICY_CACHE_TTL_MS) return null;
-  return cached;
-};
-var deriveDecisionSource = (toolName, toolInput, liveMode) => {
-  try {
-    if (liveMode.kill) return "terminal";
-    const policy = readFreshCachedPolicy(getApiKey());
-    if (!policy) return void 0;
-    const resolved = resolvePolicy(policy, toolName, liveMode.mode, toolInput);
-    if (resolved.timeoutSeconds === 0 && resolved.timeoutAction === "approve") return "policy_auto";
-    if (resolved.mode === "push_only" || resolved.mode === "push_first") return "human";
-    return "terminal";
-  } catch {
-    return void 0;
-  }
-};
-var deriveUsage = (transcriptPath, sessionId) => {
-  if (!transcriptPath || process.env.PUSHARY_COST_TRACKING === "off") return void 0;
-  try {
-    return readNewUsage(transcriptPath, sessionId || DEFAULT_SESSION) ?? void 0;
-  } catch {
-    return void 0;
-  }
-};
-var reportEvent = async (event, options = {}) => {
-  const apiKey = getApiKey();
-  const baseUrl = getBaseUrl();
-  return withRetry(async () => {
-    const res = await fetch(`${baseUrl}/api/agent/event`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        ...event,
-        machineId: event.machineId ?? getMachineId()
-      }),
-      signal: AbortSignal.timeout(options.timeoutMs ?? 1e4)
-    });
-    try {
-      return await res.json();
-    } catch {
-      return null;
-    }
-  }, { maxAttempts: options.maxAttempts ?? 2, baseDelayMs: 300 });
-};
-var handlePostToolUse = async (input, agent = CLAUDE_CODE_AGENT) => {
-  try {
-    const projectName = basename(input.cwd ?? process.cwd());
-    const action = describeToolCall(input.tool_name, input.tool_input, "event");
-    const lookup = toPolicyLookup(input.tool_name, input.tool_input);
-    const isError = isToolResultError(input.tool_result);
-    const receiptsEnabled = process.env.PUSHARY_RECEIPTS !== "off";
-    const liveMode = await fetchModeState(getApiKey(), input.session_id);
-    await Promise.allSettled([
-      cleanupPendingQuestions(input.session_id || DEFAULT_SESSION),
-      reportEvent({
-        event: isError ? "tool_error" : "tool_complete",
-        agentType: agent.type,
-        agentName: `${agent.label} - ${projectName}`,
-        action,
-        sessionId: input.session_id,
-        error: isError ? String(input.tool_result?.error ?? input.tool_result?.stderr ?? "").slice(0, 500) : void 0,
-        decisionSource: deriveDecisionSource(lookup.tool, lookup.input, liveMode),
-        meta: receiptsEnabled ? deriveReceiptMeta(lookup.tool, lookup.input, input.tool_result, input.cwd ?? process.cwd()) : void 0,
-        usage: deriveUsage(input.transcript_path, input.session_id)
-      })
-    ]);
-  } catch {
-  }
-};
-var TASK_TITLE_MAX_LENGTH = 120;
-var handleUserPrompt = async (input, agent = CLAUDE_CODE_AGENT) => {
-  try {
-    const projectName = basename(input.cwd ?? process.cwd());
-    const titlesEnabled = process.env.PUSHARY_TASK_TITLES !== "off";
-    const taskTitle = titlesEnabled ? input.prompt?.replace(/\s+/g, " ").trim().slice(0, TASK_TITLE_MAX_LENGTH) || void 0 : void 0;
-    await reportEvent({
-      event: "user_prompt",
-      agentType: agent.type,
-      agentName: `${agent.label} - ${projectName}`,
-      sessionId: input.session_id,
-      taskTitle
-    }, { maxAttempts: 1, timeoutMs: 800 });
-  } catch {
-  }
-};
-var handleStop = async (input, agent = CLAUDE_CODE_AGENT) => {
-  try {
-    const projectName = basename(input.cwd ?? process.cwd());
-    const [, reported] = await Promise.allSettled([
-      cleanupPendingQuestions(input.session_id || DEFAULT_SESSION),
-      reportEvent({
-        event: "session_end",
-        agentType: agent.type,
-        agentName: `${agent.label} - ${projectName}`,
-        action: "Session ended",
-        sessionId: input.session_id,
-        usage: deriveUsage(input.transcript_path, input.session_id)
-      })
-    ]);
-    const pendingCommand = reported.status === "fulfilled" ? reported.value?.pendingCommand : void 0;
-    if (typeof pendingCommand === "string" && pendingCommand.trim().length > 0) {
-      return {
-        decision: "block",
-        reason: `The user sent a new instruction from their phone via Pushary: ${pendingCommand.trim()}`
-      };
-    }
-    return void 0;
-  } catch {
-    return void 0;
-  }
-};
-var handleNotification = async (input) => {
-  try {
-    const projectName = basename(input.cwd ?? process.cwd());
-    await reportEvent({
-      event: input.type === "error" ? "error" : "notification",
-      agentType: "claude_code",
-      agentName: `Claude Code - ${projectName}`,
-      action: input.title ?? input.message ?? "Notification",
-      sessionId: input.session_id,
-      error: input.type === "error" ? input.message : void 0
-    });
-  } catch {
-  }
-};
-
-export {
-  CODEX_AGENT,
-  codexAllow,
-  codexDeny,
-  codexPass,
-  toCodexWire,
-  toPolicyLookup,
-  permissionTimeoutDecision,
-  preToolUseTimeoutDecision,
-  reportEvent,
-  handlePostToolUse,
-  handleUserPrompt,
-  handleStop,
-  handleNotification
-};

package/dist/chunk-3LC4YUMA.js

@@ -1,194 +0,0 @@
-import {
-  denyReasonFrom,
-  isDeferAnswer
-} from "./chunk-KQYIHZ5E.js";
-import {
-  DEFAULT_SESSION,
-  askUser,
-  deriveAction,
-  deriveActionBody,
-  deriveBlocker,
-  deriveToolTarget,
-  describeToolCall,
-  fetchModeState,
-  getMachineId,
-  getPolicy,
-  readLastPrompt,
-  readLastUserPrompt,
-  resolvePolicy,
-  savePendingQuestion,
-  sendNotification,
-  waitForAnswer
-} from "./chunk-5LTQNC7R.js";
-import {
-  getApiKey
-} from "./chunk-NKXSILEW.js";
-
-// src/hook.ts
-import { basename } from "path";
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var allow = () => ({
-  hookSpecificOutput: {
-    hookEventName: "PreToolUse",
-    permissionDecision: "allow"
-  }
-});
-var deny = (reason) => ({
-  hookSpecificOutput: {
-    hookEventName: "PreToolUse",
-    permissionDecision: "deny",
-    permissionDecisionReason: reason
-  }
-});
-var ask = (reason) => ({
-  hookSpecificOutput: {
-    hookEventName: "PreToolUse",
-    permissionDecision: "ask",
-    ...reason ? { permissionDecisionReason: reason } : {}
-  }
-});
-var pollForAnswer = async (apiKey, correlationId, deadlineMs, pollInterval = 2e3) => {
-  while (Date.now() < deadlineMs) {
-    const remaining = Math.min(Math.max(deadlineMs - Date.now(), 1e3), 3e4);
-    let answer;
-    try {
-      answer = await waitForAnswer(apiKey, correlationId, remaining);
-    } catch {
-      if (Date.now() + pollInterval >= deadlineMs) break;
-      await sleep(pollInterval);
-      continue;
-    }
-    if (answer.answered) return answer;
-    if (Date.now() + pollInterval >= deadlineMs) break;
-    await sleep(pollInterval);
-  }
-  return { answered: false };
-};
-var handlePushOnly = async (apiKey, description, projectName, timeoutSeconds, timeoutAction, sessionId, machineId, toolName, toolTarget, decision) => {
-  let result;
-  try {
-    result = await askUser(apiKey, {
-      question: `Allow ${description}?`,
-      type: "confirm",
-      context: `Agent wants to run this in ${projectName}`,
-      agentName: `Claude Code - ${projectName}`,
-      sessionId,
-      machineId,
-      toolName,
-      toolTarget,
-      ...decision
-    });
-  } catch {
-    switch (timeoutAction) {
-      case "approve":
-        return allow();
-      case "deny":
-        return deny("Push notification failed, denying per policy");
-      default:
-        return ask("Push notification failed, asking in terminal");
-    }
-  }
-  const deadline = Date.now() + timeoutSeconds * 1e3;
-  const answer = await pollForAnswer(apiKey, result.correlationId, deadline);
-  if (answer.answered) {
-    if (isDeferAnswer(answer.value)) return ask("Handling on your machine");
-    return answer.value === "yes" ? allow() : deny(denyReasonFrom(answer.value));
-  }
-  switch (timeoutAction) {
-    case "approve":
-      return allow();
-    case "deny":
-      return deny("No response within timeout");
-    default:
-      return ask("No push response, asking in terminal");
-  }
-};
-var handleTerminalOnly = () => {
-  return ask();
-};
-var handlePushFirst = async (apiKey, description, projectName, pushFirstSeconds, sessionId, machineId, toolName, toolTarget, decision) => {
-  let result;
-  try {
-    result = await askUser(apiKey, {
-      question: `Allow ${description}?`,
-      type: "confirm",
-      context: `Agent wants to run this in ${projectName}`,
-      agentName: `Claude Code - ${projectName}`,
-      sessionId,
-      machineId,
-      toolName,
-      toolTarget,
-      ...decision
-    });
-  } catch {
-    return ask("Push notification failed, asking in terminal");
-  }
-  const deadline = Date.now() + pushFirstSeconds * 1e3;
-  const answer = await pollForAnswer(apiKey, result.correlationId, deadline, 1500);
-  if (answer.answered) {
-    if (isDeferAnswer(answer.value)) return ask("Handling on your machine");
-    return answer.value === "yes" ? allow() : deny(denyReasonFrom(answer.value));
-  }
-  savePendingQuestion(sessionId || DEFAULT_SESSION, result.correlationId);
-  return ask("Sent as push notification. You can also approve here.");
-};
-var handleNotifyOnly = async (apiKey, description, projectName, sessionId, machineId) => {
-  try {
-    await sendNotification(apiKey, {
-      title: "Agent needs approval",
-      body: description,
-      agentName: `Claude Code - ${projectName}`,
-      sessionId,
-      machineId
-    });
-  } catch {
-  }
-  return ask();
-};
-var handlePreToolUse = async (input) => {
-  try {
-    const apiKey = getApiKey();
-    const modeState = await fetchModeState(apiKey, input.session_id);
-    const policy = await getPolicy(apiKey, modeState.policyVersion);
-    if (modeState.kill) {
-      return deny("Stopped by user \u2014 this agent was halted from Pushary");
-    }
-    const toolPolicy = resolvePolicy(policy, input.tool_name, modeState.mode, input.tool_input);
-    if (toolPolicy.timeoutSeconds === 0 && toolPolicy.timeoutAction === "approve") {
-      return allow();
-    }
-    if (toolPolicy.timeoutSeconds === 0 && toolPolicy.timeoutAction === "deny") {
-      return deny(`Denied by policy for ${toolPolicy.tool}`);
-    }
-    const description = describeToolCall(input.tool_name, input.tool_input, "hook");
-    const projectName = basename(input.cwd ?? process.cwd());
-    const sessionId = input.session_id;
-    const machineId = getMachineId();
-    const toolTarget = deriveToolTarget(input.tool_name, input.tool_input);
-    const intent = readLastPrompt(sessionId ?? DEFAULT_SESSION) ?? (input.transcript_path ? readLastUserPrompt(input.transcript_path) : void 0);
-    const decision = {
-      intent,
-      action: deriveAction(input.tool_name, input.tool_input),
-      blocker: deriveBlocker(toolPolicy.mode),
-      actionBody: deriveActionBody(input.tool_name, input.tool_input)
-    };
-    switch (toolPolicy.mode) {
-      case "push_only":
-        return handlePushOnly(apiKey, description, projectName, toolPolicy.timeoutSeconds, toolPolicy.timeoutAction, sessionId, machineId, input.tool_name, toolTarget, decision);
-      case "terminal_only":
-        return handleTerminalOnly();
-      case "push_first":
-        return handlePushFirst(apiKey, description, projectName, toolPolicy.pushFirstSeconds, sessionId, machineId, input.tool_name, toolTarget, decision);
-      case "notify_only":
-        return handleNotifyOnly(apiKey, description, projectName, sessionId, machineId);
-      default:
-        return handlePushFirst(apiKey, description, projectName, toolPolicy.pushFirstSeconds, sessionId, machineId, input.tool_name, toolTarget, decision);
-    }
-  } catch {
-    return ask("Pushary unavailable, falling back to terminal approval");
-  }
-};
-
-export {
-  handlePreToolUse
-};

package/dist/chunk-3MIR7ODJ.js

@@ -1,112 +0,0 @@
-import {
-  getBaseUrl
-} from "./chunk-VUNL35KE.js";
-
-// src/retry.ts
-var isRetryable = (err) => {
-  if (!(err instanceof Error)) return false;
-  const msg = err.message;
-  return /\b(502|503|429)\b/.test(msg) || /ECONNRESET|ECONNREFUSED|ETIMEDOUT|UND_ERR_CONNECT_TIMEOUT|fetch failed/i.test(msg) || msg.includes("AbortError");
-};
-var withRetry = async (fn, options = {}) => {
-  const {
-    maxAttempts = 3,
-    baseDelayMs = 500,
-    maxDelayMs = 5e3,
-    shouldRetry = isRetryable
-  } = options;
-  let lastError;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      return await fn();
-    } catch (err) {
-      lastError = err;
-      if (attempt + 1 >= maxAttempts || !shouldRetry(err)) throw err;
-      const jitter = Math.random() * 0.3 + 0.85;
-      const delay = Math.min(baseDelayMs * 2 ** attempt * jitter, maxDelayMs);
-      await new Promise((r) => setTimeout(r, delay));
-    }
-  }
-  throw lastError;
-};
-
-// src/mcp-http.ts
-var parseSseJson = (body) => {
-  const messages = [];
-  for (const event of body.split(/\r?\n\r?\n/)) {
-    const data = event.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n").trim();
-    if (!data) continue;
-    try {
-      messages.push(JSON.parse(data));
-    } catch {
-    }
-  }
-  const message = messages.at(-1);
-  if (!message) throw new Error("Empty response from Pushary");
-  return message;
-};
-var parseMcpResponse = (body, contentType) => {
-  if (contentType?.includes("text/event-stream")) {
-    return parseSseJson(body);
-  }
-  return JSON.parse(body);
-};
-var sendMcpRequest = async (apiKey, message, options = {}) => {
-  return withRetry(async () => {
-    const baseUrl = options.baseUrl ?? getBaseUrl();
-    const fetchFn = options.fetchFn ?? fetch;
-    const headers = {
-      "Content-Type": "application/json",
-      "Accept": "application/json, text/event-stream",
-      "Authorization": `Bearer ${apiKey}`
-    };
-    if (options.sessionId) {
-      headers["Mcp-Session-Id"] = options.sessionId;
-    }
-    const response = await fetchFn(`${baseUrl}/api/mcp/mcp`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(message),
-      signal: options.timeoutMs ? AbortSignal.timeout(options.timeoutMs) : void 0
-    });
-    const body = await response.text();
-    const contentType = response.headers.get("content-type");
-    let data = null;
-    if (body.trim()) {
-      try {
-        data = parseMcpResponse(body, contentType);
-      } catch (err) {
-        if (response.ok) throw err;
-      }
-    }
-    if (!response.ok) {
-      const msg = data?.error?.message ?? (body.trim() || response.statusText);
-      throw new Error(`Pushary MCP error: ${response.status} ${msg}`);
-    }
-    if (!data) throw new Error("Empty response from Pushary");
-    if (data.error) throw new Error(data.error.message ?? "Pushary MCP error");
-    return {
-      data,
-      sessionId: response.headers.get("mcp-session-id") ?? "",
-      status: response.status,
-      statusText: response.statusText
-    };
-  }, { maxAttempts: options.maxRetries ?? 1 });
-};
-var callMcpTool = async (apiKey, toolName, params, options = {}) => {
-  const { data } = await sendMcpRequest(apiKey, {
-    jsonrpc: "2.0",
-    id: options.id ?? Date.now(),
-    method: "tools/call",
-    params: { name: toolName, arguments: params }
-  }, options);
-  const text = data.result?.content?.[0]?.text;
-  if (!text) throw new Error("Empty response from Pushary");
-  return JSON.parse(text);
-};
-
-export {
-  withRetry,
-  sendMcpRequest,
-  callMcpTool
-};