@paigy/mcp 0.12.1 → 0.13.0

package/dist/chunk-ACPCCDHI.js

@@ -1,451 +0,0 @@
-import {
-  BACKEND_URL,
-  reach
-} from "./chunk-GU7C5H6L.js";
-
-// ../../packages/schema/dist/index.js
-import { z } from "zod";
-var ContextSchema = z.object({
-  title: z.string().min(1).describe("One-line headline of what you need (required, non-empty)."),
-  description: z.array(z.string().min(1)).min(1).describe("Semantic chunks of detail (each a standalone, non-empty piece). The user can select chunks to ask you to expand.")
-});
-var OptionSchema = z.object({
-  id: z.string(),
-  label: z.string(),
-  // .describe() flows into the MCP notify_user JSON schema (zodToJsonSchema), so
-  // the constraints below are what an agent reads when deciding to use these.
-  html: z.string().max(16384).describe(
-    "Optional sandboxed HTML/CSS preview for a visual 'pick one' (shown in the option card). Untrusted-sandboxed: NO JavaScript, NO external network or images \u2014 inline CSS and data: URIs only; <=16KB. Use for layout/CSS mockups, tables, diffs. For a hosted image use `image` instead."
-  ).optional(),
-  image: z.string().url().describe(
-    "Optional image URL rendered as the option's preview (plain image, not sandboxed). For agent-generated HTML/CSS mockups, use `html` instead."
-  ).optional()
-});
-var VisualSchema = z.object({
-  url: z.string().url(),
-  label: z.string().optional()
-});
-var NotifyLevelSchema = z.enum(["inbox", "push", "banner", "call"]);
-var NotifyRequestSchema = z.object({
-  context: ContextSchema,
-  options: z.array(OptionSchema.omit({ id: true })).min(1).optional().describe(
-    "The choices, in order \u2014 required when select is 'one'/'many'/'rank', omitted otherwise. Ids are assigned automatically by position ('1', '2', \u2026); the user's answer references them as optionId(s)."
-  ),
-  visuals: z.array(VisualSchema).optional().describe(
-    "Images attached to the message itself \u2014 context for the whole question (a screenshot, a chart). For a preview on one selectable choice, use that option's `html`/`image` instead."
-  ),
-  /** Git repo the agent is working in ("owner/name"). Local MCP fills this from the checkout — omit unless overriding. */
-  repo: z.string().optional(),
-  /** Git branch the agent is on. Local MCP fills this from the checkout — omit unless overriding. */
-  branch: z.string().optional(),
-  /** Continue an existing conversation; omitted = start a new thread. */
-  threadId: z.string().uuid().optional(),
-  urgency: NotifyLevelSchema.default("inbox").describe(
-    "The level you're requesting \u2014 the user's account permissions + session mode can lower it. 'inbox' (default) = sits silently in the inbox for the user to get to. 'push' = a quiet passive push (lands in Notification Center, no sound) \u2014 a gentle heads-up. 'banner' = a time-sensitive banner/lock-screen push with sound (a 'paige') they tap to open \u2014 use when you need them soon-ish but it's not worth ringing them. 'call' = rings the user's phone now (a CallKit voice call) \u2014 use only when you genuinely need them in the moment (blocked and waiting, time-sensitive). context.title is what they see on the banner/ring, so make it specific."
-  ),
-  /** The request this one was spawned from, for a clarification. */
-  parentId: z.string().optional(),
-  select: z.enum(["one", "many", "rank", "confirm", "text"]).describe(
-    "How the user answers \u2014 required, pick the shape that fits the question: 'one' = pick one option, 'many' = pick several, 'rank' = pick & order (each needs `options`); 'confirm' = yes/no or approve/deny; 'text' = free-form reply only (status updates, open questions). 'confirm' and 'text' take no options."
-  ),
-  confirmStyle: z.enum(["yesno", "approve"]).default("yesno").describe(
-    "Labels for a select:'confirm' paige \u2014 'yesno' (Yes/No) or 'approve' (Approve/Deny). Ignored unless select is 'confirm'."
-  ),
-  blocking: z.boolean().default(false).describe(
-    "Set true when real downstream work is stuck behind this specific decision \u2014 you can't make meaningful progress until it's answered. This is the real signal for how urgently the user should be reached; it's what the premier use case (an agent that stays unblocked instead of going idle) depends on. Independent of `urgency`: a `banner`-level question can still be `blocking` (something IS stuck, just not time-critical enough to ring for immediately) \u2014 if it goes unanswered a while, Paigy escalates it to a real call using this flag rather than guessing from how many other things happen to be pending. Leave false for anything you could work around, defer, or where other useful work exists meanwhile."
-  )
-}).superRefine((r, ctx) => {
-  const needsOptions = r.select === "one" || r.select === "many" || r.select === "rank";
-  if (needsOptions && !r.options?.length)
-    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["options"], message: `select:'${r.select}' requires options` });
-  if (!needsOptions && r.options?.length)
-    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["options"], message: `select:'${r.select}' takes no options` });
-});
-var NotifyStatusSchema = z.enum(["pending", "answered", "ignored"]);
-var AgentStateSchema = z.enum(["idle", "in_progress", "completed", "needs_input"]);
-var SetTaskStateSchema = z.object({
-  state: z.enum(["in_progress", "completed", "needs_input"])
-});
-var TurnSchema = z.object({
-  prompt: z.string(),
-  reply: z.string()
-});
-var UserAnswerSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("option"), optionId: z.string() }),
-  z.object({ kind: z.literal("text"), text: z.string() }),
-  z.object({ kind: z.literal("ignored") }),
-  z.object({ kind: z.literal("multi"), optionIds: z.array(z.string()) }),
-  z.object({ kind: z.literal("ranked"), optionIds: z.array(z.string()) }),
-  z.object({ kind: z.literal("clarify"), chunks: z.array(z.string()).min(1) }),
-  z.object({ kind: z.literal("confirm"), approved: z.boolean() }),
-  z.object({ kind: z.literal("turns"), turns: z.array(TurnSchema).min(1) })
-]);
-var AwaitItemSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("reply"),
-    threadId: z.string(),
-    notificationId: z.string(),
-    answer: UserAnswerSchema
-  }),
-  z.object({
-    type: z.literal("remind"),
-    threadId: z.string(),
-    notificationId: z.string(),
-    remindAt: z.string().datetime({ offset: true }),
-    /** Seconds until remindAt, server-computed — pass straight to ScheduleWakeup. */
-    remindInSeconds: z.number()
-  }),
-  z.object({ type: z.literal("idle") })
-]);
-var CallbackTriggerSchema = z.enum(["on_done", "on_blocked", "scheduled"]);
-var ScheduleCallbackSchema = z.object({
-  threadId: z.string().describe("The thread to call back on (from a prior notify_user / reply / request)."),
-  trigger: CallbackTriggerSchema,
-  dueInSeconds: z.number().int().positive().optional().describe("For 'scheduled' only: how many seconds from now to fire."),
-  note: z.string().optional().describe("What to tell the user when you follow up.")
-});
-var PendingRepliesSchema = z.object({
-  replies: z.array(
-    z.object({ threadId: z.string(), notificationId: z.string(), answer: UserAnswerSchema })
-  ),
-  pending: z.array(
-    z.object({ threadId: z.string(), notificationId: z.string(), createdAt: z.string() })
-  ),
-  /** User-initiated requests addressed to this agent; act on them and reply via
-   *  notify_user on the same threadId. Keeps reappearing until you call
-   *  set_task_state on its notificationId. */
-  requests: z.array(
-    z.object({ threadId: z.string(), notificationId: z.string(), text: z.string(), createdAt: z.string() })
-  ),
-  /** Callbacks you owe the user that are now DUE (you said you'd follow up when done,
-   *  if blocked, or at a time that has passed). Re-surfaced every sweep until you
-   *  fulfill one by calling notify_user on its threadId. */
-  owedCallbacks: z.array(
-    z.object({ threadId: z.string(), trigger: CallbackTriggerSchema, note: z.string() })
-  ),
-  /** Work (either direction) you reported in_progress a while ago and never reported
-   *  completed — likely left half-done by this session or a prior one that crashed or
-   *  went idle. Report a real state (set_task_state) or continue the work. */
-  stalled: z.array(
-    z.object({ threadId: z.string(), notificationId: z.string(), title: z.string().nullable(), startedAt: z.string() })
-  )
-});
-var NotifyResponseSchema = z.object({
-  notificationId: z.string(),
-  status: NotifyStatusSchema,
-  createdAt: z.string().datetime(),
-  answer: UserAnswerSchema.optional(),
-  answeredAt: z.string().datetime().optional()
-});
-var UserResponseSchema = z.object({
-  requestId: z.string(),
-  answer: UserAnswerSchema,
-  answeredAt: z.string().datetime()
-});
-var InboxItemSchema = z.object({
-  id: z.string(),
-  status: NotifyStatusSchema,
-  context: ContextSchema,
-  options: z.array(OptionSchema).optional(),
-  visuals: z.array(VisualSchema).optional(),
-  agent: z.string(),
-  nickname: z.string(),
-  repo: z.string().optional(),
-  branch: z.string().optional(),
-  createdAt: z.string().datetime(),
-  snoozedUntil: z.string().datetime().optional(),
-  agentState: AgentStateSchema.default("idle"),
-  /** Whose action the item is waiting on: "you" = an agent asked you (the default,
-   *  every agent→user notification); "agent" = you sent a request and it's awaiting the
-   *  agent (held in the inbox until the agent replies on the thread). */
-  turn: z.enum(["you", "agent"]).default("you"),
-  /** Hard error reason on an awaiting request (turn="agent") — the wake failed to reach
-   *  the agent (provider-agnostic; set server-side). Absent = no hard error, though the
-   *  client may still flag a stall by age. Drives the inbox error badge + Retry. */
-  error: z.string().optional(),
-  parentId: z.string().optional(),
-  select: z.enum(["one", "many", "rank", "confirm", "text"]).default("one"),
-  confirmStyle: z.enum(["yesno", "approve"]).default("yesno").describe(
-    "Labels for a select:'confirm' paige \u2014 'yesno' (Yes/No) or 'approve' (Approve/Deny). Ignored unless select is 'confirm'."
-  ),
-  /** Real downstream work is stuck behind this one — set by the agent, independent of
-   *  urgency (see the main README's "premier use case" + notify/states.md). Drives the
-   *  inbox's blocking badge and the extra confirm step before dismissing it. */
-  blocking: z.boolean().default(false),
-  /** The user's locked-in answer; present only for replied items (GET /api/replied/:id). */
-  answer: UserAnswerSchema.optional()
-});
-var SnoozeRequestSchema = z.object({
-  requestId: z.string(),
-  until: z.string().datetime()
-});
-var PushTokenSchema = z.object({
-  voipToken: z.string().min(1).optional(),
-  alertToken: z.string().min(1).optional(),
-  fcmToken: z.string().min(1).optional(),
-  platform: z.enum(["ios", "android"])
-});
-var MissedCallSchema = z.enum([
-  "retry_10m",
-  "retry_30m",
-  "retry_60m",
-  "backoff_gentle",
-  "backoff_standard",
-  "backoff_aggressive",
-  "inbox",
-  "dismiss"
-]);
-var UserSettingsSchema = z.object({
-  permissions: z.object({
-    call: z.boolean(),
-    banner: z.boolean(),
-    push: z.boolean()
-  }),
-  sessionMode: z.enum(["default", "all_calls", "silent"]),
-  silentPush: z.boolean(),
-  autoCallback: z.boolean(),
-  /** Opt-in (default false) to using your content to improve Paigy and train models. */
-  improveConsent: z.boolean(),
-  missedCall: MissedCallSchema.default("backoff_standard"),
-  /** Where voice audio is processed. 'hosted' (default) = Paigy's voice services
-   *  (ElevenLabs TTS, faster-whisper STT, the call bot); 'on_device' = the phone
-   *  synthesizes and transcribes locally — no audio or spoken text leaves it.
-   *  Optional, NOT defaulted: a stale client PATCHing the full settings object
-   *  must not silently reset this privacy choice. Absent = leave unchanged on
-   *  write, 'hosted' on read (see store.ts). */
-  voiceMode: z.enum(["hosted", "on_device"]).optional()
-});
-var HistoryItemSchema = z.object({
-  id: z.string(),
-  threadId: z.string(),
-  /** 'user' = a request you sent; 'agent' = a notification an agent sent you. */
-  initiator: z.enum(["user", "agent"]),
-  title: z.string(),
-  /** The agent on the other end (nickname). */
-  agent: z.string(),
-  createdAt: z.string(),
-  /** When the agent fetched your request (user→agent only). */
-  agentAckedAt: z.string().nullable(),
-  /** When you answered the agent's notification (agent→user only). */
-  humanAckedAt: z.string().nullable()
-});
-var ConnectionSummarySchema = z.object({
-  /** The connection = the agent's token id (used to address a request). */
-  id: z.string(),
-  agent: z.string(),
-  device: z.string().nullable(),
-  nickname: z.string(),
-  createdAt: z.string().datetime(),
-  /** Most recent notification on this connection, either direction. Null = no contact yet.
-   *  Drives the agents-page recency grouping (Today / This week / …). */
-  lastContactAt: z.string().datetime().nullable(),
-  /** True = a provider-managed agent running in the provider's cloud (e.g. Anthropic CMA);
-   *  false = a local MCP connection running on the user's computer (Claude Code/Codex/…). */
-  managed: z.boolean()
-});
-var CreateRequestSchema = z.object({
-  /** The connection (token id) to send to, from GET /api/tokens. */
-  tokenId: z.string(),
-  /** The user's message to the agent. */
-  text: z.string().min(1)
-});
-var DeliveryModeSchema = z.enum(["poll", "self_hosted"]);
-var WAKE_EVENT = "wake";
-var wakeChannel = (tokenId) => `wake:${tokenId}`;
-var RegisterDeliverySchema = z.object({ mode: DeliveryModeSchema });
-var OAuthStartSchema = z.object({
-  provider: z.enum(["cma"]),
-  returnTo: z.string().min(1)
-});
-var DeliveryConfigSchema = z.object({
-  tokenId: z.string(),
-  mode: DeliveryModeSchema,
-  /** null when the server has no SUPABASE_ANON_KEY set — the listener then falls
-   *  back to its own PAIGY_SUPABASE_URL / PAIGY_SUPABASE_ANON_KEY env. */
-  realtime: z.object({ url: z.string(), anonKey: z.string() }).nullable()
-});
-var StatusSchema = z.object({
-  agent: z.string(),
-  nickname: z.string(),
-  sessionMode: z.enum(["default", "all_calls", "silent"]),
-  /** A phone is registered for push/ring (any push token on the account). */
-  phone: z.boolean()
-});
-var EnvelopeRecipientSchema = z.object({
-  keyId: z.string(),
-  epk: z.string(),
-  wnonce: z.string(),
-  wrap: z.string()
-});
-var EnvelopeHeaderSchema = z.object({
-  field: z.enum(["context", "options", "visuals", "answer"]),
-  kind: z.string(),
-  senderRole: z.enum(["agent", "user"]),
-  recipientKeyIds: z.array(z.string()),
-  seq: z.number().int().nonnegative()
-});
-var EnvelopeSchema = z.object({
-  v: z.literal(1),
-  alg: z.literal("x25519-xsalsa20poly1305"),
-  msgId: z.string(),
-  hdr: EnvelopeHeaderSchema,
-  recipients: z.array(EnvelopeRecipientSchema).min(1),
-  nonce: z.string(),
-  ct: z.string()
-});
-var SealedAnswerSchema = z.object({
-  ignored: z.boolean(),
-  envelope: EnvelopeSchema
-});
-var DeviceCredentialSchema = z.object({
-  deviceId: z.string(),
-  kind: z.enum(["phone", "web", "agent"]),
-  x25519Pub: z.string(),
-  ed25519Pub: z.string(),
-  sig: z.string()
-});
-var DeviceRosterSchema = z.object({
-  uikPub: z.string(),
-  devices: z.array(DeviceCredentialSchema)
-});
-var WakeNudgeSchema = z.object({
-  kind: z.enum(["reply", "request", "callback"]),
-  notificationId: z.string().optional(),
-  threadId: z.string()
-});
-var DeviceAgentTokenSchema = z.object({
-  token: z.string(),
-  deviceId: z.string(),
-  agentName: z.string(),
-  /** User-chosen session label; defaults to `<agent> <device>`. */
-  nickname: z.string(),
-  createdAt: z.string().datetime()
-});
-var PairingStatusSchema = z.enum(["pending", "approved", "denied", "expired"]);
-var DeviceCodeSchema = z.object({
-  device_code: z.string(),
-  user_code: z.string(),
-  verification_uri: z.string().url(),
-  verification_uri_complete: z.string().url(),
-  interval: z.number(),
-  expires_in: z.number()
-});
-var DeviceInfoSchema = z.object({
-  code: z.string(),
-  agent: z.string(),
-  device: z.string().nullable(),
-  status: PairingStatusSchema
-});
-var DeviceTokenSchema = z.object({
-  access_token: z.string(),
-  nickname: z.string(),
-  agent: z.string(),
-  device: z.string().nullable()
-});
-var SupportRequestSchema = z.object({
-  email: z.string().email().max(320),
-  message: z.string().trim().min(1).max(5e3),
-  name: z.string().trim().max(120).optional()
-});
-
-// src/client.ts
-import { existsSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-var TOKEN_PATH = join(homedir(), ".paigy", "token.json");
-function loadToken() {
-  if (process.env.PAIGY_TOKEN) return process.env.PAIGY_TOKEN;
-  if (existsSync(TOKEN_PATH)) {
-    try {
-      const raw = readFileSync(TOKEN_PATH, "utf8");
-      const parsed = JSON.parse(raw);
-      if (parsed.access_token) return parsed.access_token;
-    } catch {
-    }
-  }
-  return "";
-}
-var ONBOARD_MSG = "Not paired with Paigy yet \u2014 call the `pair` tool to connect this agent (it returns an approval link to show the user), then retry. Manual fallback: `npx -y @paigy/mcp paigy-mcp-onboard`.";
-function ensureAuthed(res) {
-  if (res.status === 401) throw new Error(ONBOARD_MSG);
-  return res;
-}
-async function submitNotification(req) {
-  const token = loadToken();
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/notify`, {
-    method: "POST",
-    headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
-    body: JSON.stringify(req)
-  }));
-  if (!res.ok) throw new Error(`notify failed: ${res.status} ${await res.text()}`);
-  return await res.json();
-}
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-async function awaitReply(notificationId, opts = {}) {
-  const intervalMs = opts.intervalMs ?? 5e3;
-  const windowMs = opts.windowMs ?? 3e5;
-  const doSleep = opts.sleep ?? sleep;
-  const now = opts.now ?? Date.now;
-  const token = loadToken();
-  const start = now();
-  while (true) {
-    const res = ensureAuthed(await reach(`${BACKEND_URL}/api/await?notificationId=${encodeURIComponent(notificationId)}`, {
-      headers: { authorization: `Bearer ${token}` }
-    }));
-    if (!res.ok) throw new Error(`await failed: ${res.status} ${await res.text()}`);
-    const item = await res.json();
-    if (item.type !== "idle") return item;
-    if (now() - start >= windowMs) return { type: "idle" };
-    await doSleep(intervalMs);
-  }
-}
-async function checkReplies() {
-  const token = loadToken();
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/pending`, {
-    headers: { authorization: `Bearer ${token}` }
-  }));
-  if (!res.ok) throw new Error(`check_replies failed: ${res.status} ${await res.text()}`);
-  return await res.json();
-}
-async function setTaskState(notificationId, state) {
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/notify/${notificationId}/state`, {
-    method: "PATCH",
-    headers: { "content-type": "application/json", authorization: `Bearer ${loadToken()}` },
-    body: JSON.stringify({ state })
-  }));
-  if (!res.ok) throw new Error(`set_task_state failed: ${res.status} ${await res.text()}`);
-  return await res.json();
-}
-async function registerDelivery(mode) {
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/delivery`, {
-    method: "POST",
-    headers: { "content-type": "application/json", authorization: `Bearer ${loadToken()}` },
-    body: JSON.stringify({ mode })
-  }));
-  if (!res.ok) throw new Error(`register_delivery failed: ${res.status} ${await res.text()}`);
-  return await res.json();
-}
-async function scheduleCallback(req) {
-  const token = loadToken();
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/callback`, {
-    method: "POST",
-    headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
-    body: JSON.stringify(req)
-  }));
-  if (!res.ok) throw new Error(`schedule_callback failed: ${res.status} ${await res.text()}`);
-  return await res.json();
-}
-
-export {
-  NotifyRequestSchema,
-  SetTaskStateSchema,
-  ScheduleCallbackSchema,
-  WAKE_EVENT,
-  wakeChannel,
-  submitNotification,
-  awaitReply,
-  checkReplies,
-  setTaskState,
-  registerDelivery,
-  scheduleCallback
-};

package/dist/chunk-AILC3H3U.js

@@ -1,81 +0,0 @@
-import {
-  BACKEND_URL,
-  reach
-} from "./chunk-GU7C5H6L.js";
-
-// src/device.ts
-import { execFile } from "child_process";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
-import { homedir, platform } from "os";
-import { join } from "path";
-var AGENT_NAME = process.env.PAIGY_AGENT ?? "mcp-agent";
-var TOKEN_PATH = join(homedir(), ".paigy", "token.json");
-function openBrowser(url) {
-  const cmd = platform() === "darwin" ? "open" : platform() === "win32" ? "cmd" : "xdg-open";
-  const args = platform() === "win32" ? ["/c", "start", url] : [url];
-  execFile(cmd, args, () => {
-  });
-}
-function saveToken(token) {
-  mkdirSync(join(homedir(), ".paigy"), { recursive: true });
-  writeFileSync(TOKEN_PATH, JSON.stringify(token, null, 2) + "\n", { mode: 384 });
-}
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-function readToken() {
-  if (process.env.PAIGY_TOKEN) return process.env.PAIGY_TOKEN;
-  if (existsSync(TOKEN_PATH)) {
-    try {
-      return JSON.parse(readFileSync(TOKEN_PATH, "utf8")).access_token ?? "";
-    } catch {
-    }
-  }
-  return "";
-}
-function deleteToken() {
-  if (!existsSync(TOKEN_PATH)) return false;
-  rmSync(TOKEN_PATH);
-  return true;
-}
-async function revokeToken(token) {
-  const res = await reach(`${BACKEND_URL}/api/device/revoke`, {
-    method: "POST",
-    headers: { authorization: `Bearer ${token}` }
-  });
-  return res.ok;
-}
-async function requestCode(agent = AGENT_NAME) {
-  const res = await reach(`${BACKEND_URL}/api/device/code`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ agent })
-  });
-  if (!res.ok) throw new Error(`/api/device/code failed: ${res.status} ${await res.text()}`);
-  return await res.json();
-}
-async function pollToken(deviceCode) {
-  const res = await reach(`${BACKEND_URL}/api/device/token`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ device_code: deviceCode })
-  });
-  if (res.ok) return await res.json();
-  const body = await res.json().catch(() => ({ error: "unknown" }));
-  const err = body.error ?? "unknown";
-  if (err === "authorization_pending") return null;
-  if (err === "expired_token") throw new Error("Device code expired. Start pairing again.");
-  if (err === "access_denied") throw new Error("Access denied by user. Pairing cancelled.");
-  throw new Error(`Unexpected error from /api/device/token: ${err}`);
-}
-
-export {
-  AGENT_NAME,
-  TOKEN_PATH,
-  openBrowser,
-  saveToken,
-  sleep,
-  readToken,
-  deleteToken,
-  revokeToken,
-  requestCode,
-  pollToken
-};

package/dist/chunk-GU7C5H6L.js

@@ -1,15 +0,0 @@
-// src/http.ts
-var BACKEND_URL = process.env.PAIGY_BACKEND_URL ?? "https://paigy.ai";
-var NETWORK_MSG = `Can't reach ${BACKEND_URL} \u2014 the connection was blocked or dropped before an HTTP response. If this agent runs in a sandboxed environment with a network allowlist (e.g. Claude Code on the web, CI), ask the user to add the Paigy domain (paigy.ai) to the environment's allowed domains, then retry.`;
-async function reach(url, init) {
-  try {
-    return await fetch(url, init);
-  } catch (e) {
-    throw new Error(`${NETWORK_MSG} (${e?.message ?? String(e)})`);
-  }
-}
-
-export {
-  BACKEND_URL,
-  reach
-};