paisa-mcp 0.2.0 → 0.3.0

package/dist/index.js

@@ -53300,7 +53300,7 @@ async function initCrypto(client, pin, userId) {
 // ../../node_modules/.bun/@modelcontextprotocol+server@2.1.0/node_modules/@modelcontextprotocol/server/dist/index.mjs
 var DEFAULT_MAX_REQUEST_BODY_SIZE = 4 * 1024 * 1024;
 
-// ../../node_modules/.bun/@nimit9+signet-server@0.2.2+e803b2305afdb064/node_modules/@nimit9/signet-server/dist/http/status-codes.js
+// ../../node_modules/.bun/@nimit9+signet-server@0.2.3+e803b2305afdb064/node_modules/@nimit9/signet-server/dist/http/status-codes.js
 var STATUS_CODES = {
   400: "BAD_REQUEST",
   401: "UNAUTHORIZED",
@@ -53314,7 +53314,7 @@ var STATUS_CODES = {
   429: "RATE_LIMITED"
 };
 
-// ../../node_modules/.bun/@nimit9+signet-server@0.2.2+e803b2305afdb064/node_modules/@nimit9/signet-server/dist/mcp/server.js
+// ../../node_modules/.bun/@nimit9+signet-server@0.2.3+e803b2305afdb064/node_modules/@nimit9/signet-server/dist/mcp/server.js
 var RAW = Symbol.for("signet.mcp.rawResult");
 function toolResult(result) {
   return Object.defineProperty({ ...result }, RAW, { value: true, enumerable: false });
@@ -53398,10 +53398,17 @@ function toResult(value, structured) {
   return { content: [{ type: "text", text }] };
 }
 function createMcpServer(options) {
+  const unlisted = new Set(options.tools.filter((t) => t.listed === false).map((t) => t.name));
+  const toolsCapability = { tools: { listChanged: false } };
   const server = new McpServer({ name: options.name, version: options.version }, {
-    capabilities: { tools: { listChanged: false } },
+    ...unlisted.size ? {} : { capabilities: toolsCapability },
     ...options.instructions ? { instructions: options.instructions } : {}
   });
+  let restore;
+  if (unlisted.size) {
+    server.server.registerCapabilities(toolsCapability);
+    restore = hideUnlisted(server, unlisted);
+  }
   const register2 = server.registerTool.bind(server);
   const { c, token } = options.context ?? {};
   for (const tool of options.tools) {
@@ -53445,29 +53452,110 @@ function createMcpServer(options) {
       ...tool.input ? { inputSchema: tool.input } : {},
       ...tool.output ? { outputSchema: tool.output } : {}
     }, tool.input ? (input2, mcp) => run(input2, mcp) : (mcp) => run({}, mcp));
+    restore?.();
+    restore = undefined;
   }
   return server;
 }
+function hideUnlisted(server, unlisted) {
+  const inner = server.server;
+  const original = inner.setRequestHandler.bind(inner);
+  let caught = false;
+  inner.setRequestHandler = (method, handler) => {
+    if (method !== "tools/list" || typeof handler !== "function")
+      return original(method, handler);
+    caught = true;
+    original(method, async (request, ctx) => {
+      const result = await handler(request, ctx);
+      return { ...result, tools: result.tools.filter((t) => !unlisted.has(t.name)) };
+    });
+  };
+  return () => {
+    delete inner.setRequestHandler;
+    if (!caught)
+      throw new Error("signet mcp: could not hide unlisted tools; @modelcontextprotocol/server no longer installs tools/list through setRequestHandler");
+  };
+}
+
+// src/annotations.ts
+var RO = { readOnlyHint: true, openWorldHint: false };
+var WI = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var W = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: false,
+  openWorldHint: false
+};
+var D = {
+  readOnlyHint: false,
+  destructiveHint: true,
+  idempotentHint: false,
+  openWorldHint: false
+};
+var WI_OPEN = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: true
+};
+var TOOL_META = {
+  get_transactions: { title: "Search Transactions", annotations: RO },
+  get_uncategorized_groups: { title: "Group Uncategorized Transactions", annotations: RO },
+  categorize_groups: { title: "Categorize Transaction Groups", annotations: W },
+  backfill_persons: { title: "Backfill Persons from Transactions", annotations: WI },
+  update_transaction: { title: "Update Transaction", annotations: WI },
+  bulk_link_entity: { title: "Bulk Link Transactions", annotations: WI },
+  manage_duplicates: { title: "Manage Duplicate Transactions", annotations: W },
+  get_reconciliation_context: { title: "Get Reconciliation Context", annotations: RO },
+  bulk_categorize_transactions: { title: "Bulk Categorize Transactions", annotations: WI },
+  delete_transactions: { title: "Delete Transactions", annotations: D },
+  rescan_transactions: { title: "Rescan Transactions", annotations: WI },
+  get_settlement_candidates: { title: "Find Settlement Candidates", annotations: RO },
+  get_transaction: { title: "Get Transaction", annotations: RO },
+  preview_import: { title: "Preview Statement Import", annotations: RO },
+  import_statement: { title: "Import Statement", annotations: W },
+  auto_categorize_jev: { title: "Auto-Categorize with Jev", annotations: W },
+  list_entities: { title: "List Entities", annotations: RO },
+  upsert_entity: { title: "Create or Update Entity", annotations: W },
+  delete_entity: { title: "Delete Entity", annotations: D },
+  merge_merchants: { title: "Merge Merchants", annotations: D },
+  get_analytics: { title: "Get Analytics", annotations: RO },
+  upsert_savings: { title: "Create or Update Savings Vehicle", annotations: W },
+  contribute_to_goal: { title: "Contribute to Goal", annotations: W },
+  set_budget: { title: "Set Budget", annotations: WI },
+  get_dashboard: { title: "Get Dashboard", annotations: RO },
+  sync_recurring: { title: "Sync Recurring Merchants", annotations: WI },
+  check_alerts: { title: "Check Alerts", annotations: W },
+  manage_alerts: { title: "Manage Alerts and Rules", annotations: WI },
+  manage_debt: { title: "Add or Settle Debt", annotations: W },
+  generate_monthly_report: { title: "Generate Monthly Report", annotations: WI },
+  get_report: { title: "Get Report", annotations: RO },
+  export_transactions: { title: "Export Transactions", annotations: RO },
+  set_learning_rule: { title: "Set Learning Rule", annotations: WI },
+  update_net_worth: { title: "Update Net Worth", annotations: WI },
+  upsert_investment: { title: "Create or Update Investment", annotations: W },
+  sync_zerodha: { title: "Sync Zerodha", annotations: WI_OPEN },
+  get_settings: { title: "Get Settings", annotations: RO },
+  update_settings: { title: "Update Settings", annotations: WI },
+  set_encryption_mode: { title: "Set Encryption Mode", annotations: D }
+};
+function applyAnnotations(tools) {
+  return tools.map((tool) => {
+    const meta3 = TOOL_META[tool.name];
+    if (!meta3)
+      throw new Error(`No TOOL_META entry for tool "${tool.name}" — add one to annotations.ts`);
+    return { ...tool, title: meta3.title, annotations: meta3.annotations };
+  });
+}
 // src/lib/union-tool.ts
 function variant(input2, run) {
   return { input: input2, run };
 }
-function isAlias(tool) {
-  return typeof tool.aliasFor === "string";
-}
-function aliasTool(name, input2, aliasFor, note, route) {
-  const tool = defineTool({
-    name,
-    description: `Deprecated alias of ${aliasFor}.`,
-    input: input2,
-    handler: async (args, ctx) => {
-      const [to, next] = route(args);
-      const parsed = to.input ? await to.input.parseAsync(next) : next;
-      return to.handler(parsed, ctx);
-    }
-  });
-  return { ...tool, aliasFor, aliasNote: note };
-}
 function compactJsonSchema(schema) {
   const walk = (node2, root) => {
     if (Array.isArray(node2))
@@ -53564,91 +53652,7 @@ function unionTool(opts) {
       return v.run(rest, ctx);
     }
   });
-  return {
-    tool,
-    alias: (aliasName, value) => aliasTool(aliasName, variants[value].input, name, `${key}: "${value}"`, (a) => [
-      tool,
-      { ...a, [key]: value }
-    ])
-  };
-}
-
-// src/annotations.ts
-var RO = { readOnlyHint: true, openWorldHint: false };
-var WI = {
-  readOnlyHint: false,
-  destructiveHint: false,
-  idempotentHint: true,
-  openWorldHint: false
-};
-var W = {
-  readOnlyHint: false,
-  destructiveHint: false,
-  idempotentHint: false,
-  openWorldHint: false
-};
-var D = {
-  readOnlyHint: false,
-  destructiveHint: true,
-  idempotentHint: false,
-  openWorldHint: false
-};
-var WI_OPEN = {
-  readOnlyHint: false,
-  destructiveHint: false,
-  idempotentHint: true,
-  openWorldHint: true
-};
-var TOOL_META = {
-  get_transactions: { title: "Search Transactions", annotations: RO },
-  get_uncategorized_groups: { title: "Group Uncategorized Transactions", annotations: RO },
-  categorize_groups: { title: "Categorize Transaction Groups", annotations: W },
-  backfill_persons: { title: "Backfill Persons from Transactions", annotations: WI },
-  update_transaction: { title: "Update Transaction", annotations: WI },
-  bulk_link_entity: { title: "Bulk Link Transactions", annotations: WI },
-  manage_duplicates: { title: "Manage Duplicate Transactions", annotations: W },
-  get_reconciliation_context: { title: "Get Reconciliation Context", annotations: RO },
-  bulk_categorize_transactions: { title: "Bulk Categorize Transactions", annotations: WI },
-  delete_transactions: { title: "Delete Transactions", annotations: D },
-  rescan_transactions: { title: "Rescan Transactions", annotations: WI },
-  get_settlement_candidates: { title: "Find Settlement Candidates", annotations: RO },
-  get_transaction: { title: "Get Transaction", annotations: RO },
-  preview_import: { title: "Preview Statement Import", annotations: RO },
-  import_statement: { title: "Import Statement", annotations: W },
-  auto_categorize_jev: { title: "Auto-Categorize with Jev", annotations: W },
-  list_entities: { title: "List Entities", annotations: RO },
-  upsert_entity: { title: "Create or Update Entity", annotations: W },
-  delete_entity: { title: "Delete Entity", annotations: D },
-  merge_merchants: { title: "Merge Merchants", annotations: D },
-  get_analytics: { title: "Get Analytics", annotations: RO },
-  upsert_savings: { title: "Create or Update Savings Vehicle", annotations: W },
-  contribute_to_goal: { title: "Contribute to Goal", annotations: W },
-  set_budget: { title: "Set Budget", annotations: WI },
-  get_dashboard: { title: "Get Dashboard", annotations: RO },
-  sync_recurring: { title: "Sync Recurring Merchants", annotations: WI },
-  check_alerts: { title: "Check Alerts", annotations: W },
-  manage_alerts: { title: "Manage Alerts and Rules", annotations: WI },
-  manage_debt: { title: "Add or Settle Debt", annotations: W },
-  generate_monthly_report: { title: "Generate Monthly Report", annotations: WI },
-  get_report: { title: "Get Report", annotations: RO },
-  export_transactions: { title: "Export Transactions", annotations: RO },
-  set_learning_rule: { title: "Set Learning Rule", annotations: WI },
-  update_net_worth: { title: "Update Net Worth", annotations: WI },
-  upsert_investment: { title: "Create or Update Investment", annotations: W },
-  sync_zerodha: { title: "Sync Zerodha", annotations: WI_OPEN },
-  get_settings: { title: "Get Settings", annotations: RO },
-  update_settings: { title: "Update Settings", annotations: WI },
-  set_encryption_mode: { title: "Set Encryption Mode", annotations: D }
-};
-function applyAnnotations(tools) {
-  return tools.map((tool) => {
-    if (isAlias(tool))
-      return tool;
-    const meta3 = TOOL_META[tool.name];
-    if (!meta3)
-      throw new Error(`No TOOL_META entry for tool "${tool.name}" — add one to annotations.ts`);
-    return { ...tool, title: meta3.title, annotations: meta3.annotations };
-  });
+  return { tool };
 }
 
 // src/prompts.ts
@@ -53809,11 +53813,7 @@ function alertTools(client) {
         return { success: true, generated, unread };
       }
     }),
-    manage.tool,
-    manage.alias("dismiss_alert", "dismiss"),
-    manage.alias("mark_alert_read", "read"),
-    manage.alias("list_alert_rules", "list_rules"),
-    manage.alias("set_alert_rule", "set_rule")
+    manage.tool
   ];
 }
 
@@ -54142,7 +54142,7 @@ function debtTools(client) {
       })
     }
   });
-  return [manage.tool, manage.alias("add_debt", "add"), manage.alias("settle_debt", "settle")];
+  return [manage.tool];
 }
 
 // src/tools/accounts.ts
@@ -54903,11 +54903,7 @@ function reportTools(client) {
       }),
       handler: (body) => client.post("/api/reports/generate", body)
     }),
-    report2.tool,
-    report2.alias("get_reports", "monthly"),
-    report2.alias("get_net_worth", "net_worth"),
-    report2.alias("get_upcoming", "upcoming"),
-    report2.alias("get_spending_heatmap", "heatmap")
+    report2.tool
   ];
 }
 
@@ -54986,56 +54982,7 @@ function entityTools(client, crypto3) {
       fixed_deposit: investment.deleteFd
     }
   });
-  return [
-    list.tool,
-    upsert.tool,
-    del.tool,
-    list.alias("list_categories", "categories"),
-    list.alias("list_merchants", "merchants"),
-    list.alias("list_bank_accounts", "bank_accounts"),
-    list.alias("list_persons", "persons"),
-    list.alias("list_budgets", "budgets"),
-    list.alias("list_debts", "debts"),
-    list.alias("list_invites", "invites"),
-    list.alias("list_alerts", "alerts"),
-    list.alias("list_recurring", "recurring"),
-    list.alias("list_push_subscriptions", "push_subscriptions"),
-    list.alias("list_saved_reports", "saved_reports"),
-    aliasTool("list_learning", exports_external.object({ type: exports_external.enum(LEARNING_SLICES) }), "list_entities", 'entity: "learning", slice: <type>', ({ type }) => [list.tool, { entity: "learning", slice: type }]),
-    aliasTool("list_savings", exports_external.object({
-      type: exports_external.enum(["goals", "emis", "sinking_funds", "insurance", "contributions"]),
-      id: exports_external.string().optional()
-    }), "list_entities", "entity: <type> (contributions → goal_contributions)", ({ type, id }) => {
-      if (type !== "contributions")
-        return [list.tool, { entity: type }];
-      if (!id)
-        throw new Error("list_savings type='contributions' requires id (goal UUID)");
-      return [list.tool, { entity: "goal_contributions", id }];
-    }),
-    aliasTool("list_investments", exports_external.object({
-      type: exports_external.enum(["holdings", "sips", "fixed_deposits", "transactions"]),
-      id: exports_external.string().optional()
-    }), "list_entities", "entity: <type> (transactions → investment_transactions)", ({ type, id }) => {
-      if (type !== "transactions")
-        return [list.tool, { entity: type }];
-      if (!id)
-        throw new Error("list_investments type='transactions' requires id");
-      return [list.tool, { entity: "investment_transactions", id }];
-    }),
-    upsert.alias("upsert_merchant", "merchant"),
-    upsert.alias("upsert_person", "person"),
-    upsert.alias("upsert_category", "category"),
-    upsert.alias("upsert_bank_account", "bank_account"),
-    upsert.alias("upsert_insurance", "insurance"),
-    upsert.alias("create_invite", "invite"),
-    del.alias("delete_category", "category"),
-    del.alias("delete_merchant", "merchant"),
-    del.alias("delete_person", "person"),
-    del.alias("delete_debt", "debt"),
-    del.alias("revoke_invite", "invite"),
-    aliasTool("delete_savings", exports_external.object({ type: exports_external.enum(["goal", "emi", "insurance", "sinking_fund"]), id: exports_external.string() }), "delete_entity", "entity: <type>", ({ type, id }) => [del.tool, { entity: type, id }]),
-    aliasTool("delete_investment", exports_external.object({ type: exports_external.enum(["sip", "fixed_deposit"]), id: exports_external.string() }), "delete_entity", "entity: <type>", ({ type, id }) => [del.tool, { entity: type, id }])
-  ];
+  return [list.tool, upsert.tool, del.tool];
 }
 
 // ../reconciliation/src/aliases.ts
@@ -59509,603 +59456,231 @@ function exportTools(client, crypto3) {
   ];
 }
 
-// ../../node_modules/.bun/@typesafe-ai+sdk@0.6.0/node_modules/@typesafe-ai/sdk/dist/index.mjs
-var requestIdFrom = (headers) => headers.get("x-typesafe-request-id") ?? undefined;
-var APIPromise = class APIPromise2 extends Promise {
-  #responsePromise;
-  #parseResponse;
-  #parsed;
-  constructor(responsePromise, parseResponse) {
-    super((resolve) => resolve(undefined));
-    this.#responsePromise = responsePromise;
-    this.#parseResponse = parseResponse;
-  }
-  asResponse() {
-    return this.#responsePromise;
-  }
-  async withResponse() {
-    const [data, response] = await Promise.all([this.#parse(), this.#responsePromise]);
-    return {
-      data,
-      response,
-      requestId: requestIdFrom(response.headers)
-    };
-  }
-  map(fn2) {
-    return new APIPromise2(this.#responsePromise, () => this.#parse().then(fn2));
-  }
-  #parse() {
-    this.#parsed ??= this.#responsePromise.then(this.#parseResponse);
-    return this.#parsed;
-  }
-  then(onfulfilled, onrejected) {
-    return this.#parse().then(onfulfilled, onrejected);
-  }
-  catch(onrejected) {
-    return this.#parse().catch(onrejected);
-  }
-  finally(onfinally) {
-    return this.#parse().finally(onfinally);
-  }
-};
-var ENV = {
-  apiKey: "TYPESAFE_API_KEY",
-  baseURL: "TYPESAFE_BASE_URL",
-  defaultModel: "TYPESAFE_DEFAULT_MODEL",
-  logLevel: "TYPESAFE_LOG_LEVEL"
-};
-var readEnv = (name) => {
-  if (typeof process === "undefined" || !process.env)
-    return;
-  return process.env[name]?.trim() || undefined;
-};
-var fromCodeOrEnv = (fromCode, envVar) => fromCode ?? readEnv(envVar);
-var range = (from, to2) => Array.from({ length: to2 - from }, (_2, i2) => from + i2);
-var DEFAULT_RETRY_POLICY = {
-  maxRetries: 2,
-  backoffInitialMs: 500,
-  backoffMaxMs: 5000,
-  backoffJitter: 0.25,
-  httpStatuses: /* @__PURE__ */ new Set([
-    408,
-    429,
-    ...range(500, 600)
-  ]),
-  respectRetryAfter: true,
-  maxRetryAfterMs: 60000,
-  apiConnectionError: true,
-  apiTimeoutError: true
-};
-DEFAULT_RETRY_POLICY.maxRetries;
-var isRetryableStatus = (status, policy = DEFAULT_RETRY_POLICY) => policy.httpStatuses.has(status);
-var parseRetryAfter = (headers, now = Date.now()) => {
-  const ms = Number(headers.get("retry-after-ms"));
-  if (headers.has("retry-after-ms") && Number.isFinite(ms) && ms >= 0)
-    return ms;
-  const raw = headers.get("retry-after");
-  if (raw === null)
-    return;
-  const seconds = Number(raw);
-  if (Number.isFinite(seconds))
-    return seconds >= 0 ? seconds * 1000 : undefined;
-  const date5 = Date.parse(raw);
-  if (!Number.isNaN(date5))
-    return Math.max(0, date5 - now);
-};
-var retryDelayMs = (attempt, headers, policy = DEFAULT_RETRY_POLICY, random = Math.random) => {
-  if (policy.respectRetryAfter && headers !== undefined) {
-    const retryAfter = parseRetryAfter(headers);
-    if (retryAfter !== undefined && retryAfter <= policy.maxRetryAfterMs)
-      return retryAfter;
-  }
-  const exponential = Math.min(policy.backoffInitialMs * 2 ** attempt, policy.backoffMaxMs);
-  return Math.round(exponential * (1 - random() * policy.backoffJitter));
-};
-var sleep3 = (ms, signal) => new Promise((resolve, reject) => {
-  if (signal?.aborted)
-    return reject(signal.reason);
-  const onAbort = () => {
-    clearTimeout(timer);
-    reject(signal?.reason);
-  };
-  const timer = setTimeout(() => {
-    signal?.removeEventListener("abort", onAbort);
-    resolve();
-  }, ms);
-  signal?.addEventListener("abort", onAbort, { once: true });
-});
-var TypeSafeError = class extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = new.target.name;
-  }
-};
-var isRecord = (value) => typeof value === "object" && value !== null;
-var extractMessage = (body) => {
-  if (typeof body === "string")
-    return body || undefined;
-  if (!isRecord(body))
-    return;
-  const { error: error62, message, detail } = body;
-  if (typeof error62 === "string")
-    return error62;
-  if (isRecord(error62) && typeof error62.message === "string")
-    return error62.message;
-  if (typeof message === "string")
-    return message;
-  if (typeof detail === "string")
-    return detail;
-  if (isRecord(detail) && typeof detail.message === "string")
-    return detail.message;
-  if (Array.isArray(detail))
-    return describeValidationErrors(detail);
-};
-var describeValidationErrors = (errors3) => {
-  const parts = errors3.flatMap((e2) => {
-    if (!isRecord(e2) || typeof e2.msg !== "string")
-      return [];
-    const loc = Array.isArray(e2.loc) ? e2.loc.filter((x2) => x2 !== "body").join(".") : "";
-    return [loc ? `${loc}: ${e2.msg}` : e2.msg];
-  });
-  return parts.length > 0 ? parts.join("; ") : undefined;
-};
-var MAX_RAW_BODY_IN_MESSAGE = 200;
-var APIError = class APIError2 extends TypeSafeError {
-  status;
-  headers;
-  body;
-  requestId;
-  constructor(status, body, headers, message) {
-    super(message ?? APIError2.describe(status, body));
-    this.status = status;
-    this.body = body;
-    this.headers = headers;
-    this.requestId = requestIdFrom(headers);
-  }
-  static describe(status, body) {
-    const detail = extractMessage(body);
-    if (detail)
-      return `${status} ${detail}`;
-    if (body === undefined)
-      return `${status} status code (no body)`;
-    const raw = typeof body === "string" ? body : JSON.stringify(body);
-    return `${status} ${raw.length > MAX_RAW_BODY_IN_MESSAGE ? `${raw.slice(0, MAX_RAW_BODY_IN_MESSAGE)}…` : raw}`;
-  }
-  static fromResponse(status, body, headers) {
-    if (status === 400)
-      return new BadRequestError(status, body, headers);
-    if (status === 401)
-      return new AuthenticationError(status, body, headers);
-    if (status === 403)
-      return new PermissionDeniedError(status, body, headers);
-    if (status === 404)
-      return new NotFoundError(status, body, headers);
-    if (status === 422)
-      return new UnprocessableEntityError(status, body, headers);
-    if (status === 429)
-      return new RateLimitError(status, body, headers);
-    if (status >= 500)
-      return new InternalServerError(status, body, headers);
-    return new APIError2(status, body, headers);
-  }
-};
-var BadRequestError = class extends APIError {
-};
-var AuthenticationError = class extends APIError {
-};
-var PermissionDeniedError = class extends APIError {
-};
-var NotFoundError = class extends APIError {
-};
-var UnprocessableEntityError = class extends APIError {
-};
-var RateLimitError = class extends APIError {
-  retryAfterMs = parseRetryAfter(this.headers);
-};
-var InternalServerError = class extends APIError {
-};
-var APIConnectionError = class extends TypeSafeError {
-  constructor(message = "Connection error.", options) {
-    super(message, options);
-  }
-};
-var APITimeoutError = class extends APIConnectionError {
-  timeoutMs;
-  constructor(timeoutMs, options) {
-    super(`Request timed out after ${timeoutMs}ms.`, options);
-    this.timeoutMs = timeoutMs;
-  }
-};
-var APIUserAbortError = class extends TypeSafeError {
-  constructor(message = "Request was aborted.", options) {
-    super(message, options);
-  }
-};
-var LOG_LEVELS = [
-  "debug",
-  "info",
-  "warn",
-  "error",
-  "off"
-];
-var DEFAULT_LOG_LEVEL = "warn";
-var isLogLevel = (value) => LOG_LEVELS.includes(value);
-var parseLogLevel = (value, source) => {
-  if (isLogLevel(value))
-    return value;
-  throw new TypeSafeError(`Invalid log level "${value}" from ${source}. Expected one of: ${LOG_LEVELS.join(", ")}.`);
-};
-var PREFIX = "[typesafe-sdk]";
-var consoleLogger = {
-  debug: (message, ...args) => console.debug(`${PREFIX} ${message}`, ...args),
-  info: (message, ...args) => console.info(`${PREFIX} ${message}`, ...args),
-  warn: (message, ...args) => console.warn(`${PREFIX} ${message}`, ...args),
-  error: (message, ...args) => console.error(`${PREFIX} ${message}`, ...args)
-};
-var RANK = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-  off: 4
-};
-var drop = () => {};
-var withLevel = (sink, level) => {
-  const enabled = (at2) => RANK[at2] >= RANK[level];
-  return {
-    debug: enabled("debug") ? (message, ...args) => sink.debug(message, ...args) : drop,
-    info: enabled("info") ? (message, ...args) => sink.info(message, ...args) : drop,
-    warn: enabled("warn") ? (message, ...args) => sink.warn(message, ...args) : drop,
-    error: enabled("error") ? (message, ...args) => sink.error(message, ...args) : drop
-  };
-};
-var KEY_HEADERS = /* @__PURE__ */ new Set([
-  "authorization",
-  "proxy-authorization",
-  "x-api-key"
-]);
-var OPAQUE_HEADERS = /* @__PURE__ */ new Set(["cookie", "set-cookie"]);
-var redactKey = (value) => {
-  const [scheme, secret] = value.includes(" ") ? value.split(/\s+/, 2) : [undefined, value];
-  const tail = secret && secret.length > 8 ? secret.slice(-4) : "";
-  return `${scheme ? `${scheme} ` : ""}***${tail}`;
-};
-var redact = (name, value) => {
-  const lower = name.toLowerCase();
-  if (KEY_HEADERS.has(lower))
-    return redactKey(value);
-  if (OPAQUE_HEADERS.has(lower))
-    return "***";
-  return value;
-};
-var redactHeaders = (headers) => Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, redact(name, value)]));
-var choice = (instructions, criteria) => {
-  if (Array.isArray(criteria))
-    throw new TypeSafeError("Choice criteria must be a map of labels to descriptions, not a list.");
-  return {
-    type: "choice",
-    instructions,
-    criteria
-  };
-};
-var validateQuestions = (questions) => {
-  if (Object.keys(questions).length === 0)
-    throw new TypeSafeError("At least one question is required.");
-  for (const [name, question] of Object.entries(questions)) {
-    if (question.type !== "score")
-      continue;
-    if (!Array.isArray(question.criteria))
-      throw new TypeSafeError(`Score question "${name}" has criteria that are not a list; score criteria must be a list of descriptions indexed by score from zero.`);
-    if (question.criteria.length < 2)
-      throw new TypeSafeError(`Score question "${name}" has ${question.criteria.length} criteria; at least two scores are required.`);
-  }
-};
-var Models = class {
-  #transport;
-  constructor(transport) {
-    this.#transport = transport;
-  }
-  list(options = {}) {
-    return this.#transport.request("GET", "/v1/models", options).map(unwrapModels);
-  }
-};
-var unwrapModels = (wire) => {
-  if (Array.isArray(wire?.models))
-    return wire.models;
-  throw new TypeSafeError("Unexpected response shape from GET /v1/models; expected { models: [...] }.");
-};
-var g2 = globalThis;
-var isBrowser = () => typeof g2.window !== "undefined" && typeof g2.window.document !== "undefined" && typeof g2.navigator !== "undefined";
-var describeRuntime = () => {
-  const platform = g2.process?.platform && g2.process?.arch ? ` (${g2.process.platform}; ${g2.process.arch})` : "";
-  if (g2.Bun?.version)
-    return `bun/${g2.Bun.version}${platform}`;
-  if (g2.Deno?.version?.deno)
-    return `deno/${g2.Deno.version.deno}${platform}`;
-  if (g2.EdgeRuntime !== undefined)
-    return "vercel-edge";
-  if (g2.navigator?.userAgent === "Cloudflare-Workers")
-    return "cloudflare-workers";
-  if (g2.process?.versions?.node)
-    return `node/${g2.process.versions.node}${platform}`;
-  if (isBrowser())
-    return "browser";
-  return "unknown";
-};
-var VERSION2 = "0.6.0";
-var missingApiKey = () => {
-  throw new TypeSafeError(`No API key was provided. Pass \`apiKey\` to the TypeSafeClient constructor or set the ${ENV.apiKey} environment variable.`);
-};
-var missingFetch = () => {
-  throw new TypeSafeError("No global `fetch` is available in this runtime. Pass a `fetch` implementation to the TypeSafeClient constructor.");
-};
-var refuseBrowser = () => {
-  throw new TypeSafeError("TypeSafeClient is running in a browser, which would expose your API key to anyone using the page. Call the API from a server instead, or pass `dangerouslyAllowBrowser: true` if you understand the risk.");
-};
-var defaultFetch = (input2, init) => globalThis.fetch(input2, init);
-var assertNonNegativeInteger = (name, value) => {
-  if (!Number.isInteger(value) || value < 0)
-    throw new TypeSafeError(`\`${name}\` must be a non-negative integer, got ${String(value)}.`);
-  return value;
-};
-var assertPositiveMs = (name, value) => {
-  if (!Number.isFinite(value) || value <= 0)
-    throw new TypeSafeError(`\`${name}\` must be a positive number of milliseconds, got ${String(value)}.`);
-  return value;
-};
-var assertNonNegativeMs = (name, value) => {
-  if (!Number.isFinite(value) || value < 0)
-    throw new TypeSafeError(`\`${name}\` must be a non-negative number of milliseconds, got ${String(value)}.`);
-  return value;
-};
-var assertFraction = (name, value) => {
-  if (!Number.isFinite(value) || value < 0 || value > 1)
-    throw new TypeSafeError(`\`${name}\` must be between 0 and 1, got ${String(value)}.`);
-  return value;
-};
-var assertStatusSet = (name, statuses) => {
-  for (const status of statuses)
-    if (!Number.isInteger(status) || status < 100 || status > 999)
-      throw new TypeSafeError(`\`${name}\` must contain HTTP status codes, got ${String(status)}.`);
-  return statuses;
-};
-var resolveRetryPolicy = (base, overrides) => {
-  const o2 = overrides ?? {};
-  return {
-    maxRetries: o2.maxRetries === undefined ? base.maxRetries : assertNonNegativeInteger("retry.maxRetries", o2.maxRetries),
-    backoffInitialMs: o2.backoffInitialMs === undefined ? base.backoffInitialMs : assertNonNegativeMs("retry.backoffInitialMs", o2.backoffInitialMs),
-    backoffMaxMs: o2.backoffMaxMs === undefined ? base.backoffMaxMs : assertNonNegativeMs("retry.backoffMaxMs", o2.backoffMaxMs),
-    backoffJitter: o2.backoffJitter === undefined ? base.backoffJitter : assertFraction("retry.backoffJitter", o2.backoffJitter),
-    httpStatuses: new Set(o2.httpStatuses === undefined ? base.httpStatuses : assertStatusSet("retry.httpStatuses", o2.httpStatuses)),
-    respectRetryAfter: o2.respectRetryAfter ?? base.respectRetryAfter,
-    maxRetryAfterMs: o2.maxRetryAfterMs === undefined ? base.maxRetryAfterMs : assertNonNegativeMs("retry.maxRetryAfterMs", o2.maxRetryAfterMs),
-    apiConnectionError: o2.apiConnectionError ?? base.apiConnectionError,
-    apiTimeoutError: o2.apiTimeoutError ?? base.apiTimeoutError
-  };
-};
-var isRetryableError = (err, policy) => {
-  if (err instanceof APITimeoutError)
-    return policy.apiTimeoutError;
-  if (err instanceof APIConnectionError)
-    return policy.apiConnectionError;
-  return false;
-};
-var resolveLogLevel = (fromCode) => {
-  if (fromCode !== undefined)
-    return parseLogLevel(fromCode, "the `logLevel` option");
-  const fromEnv = readEnv(ENV.logLevel);
-  if (fromEnv !== undefined)
-    return parseLogLevel(fromEnv, ENV.logLevel);
-  return DEFAULT_LOG_LEVEL;
-};
-var stripTrailingSlashes = (url3) => url3.replace(/\/+$/, "");
-var mergeHeaders = (...sources) => {
-  const entries = /* @__PURE__ */ new Map;
-  for (const source of sources)
-    for (const [name, value] of Object.entries(source))
-      if (value === undefined)
-        entries.delete(name.toLowerCase());
-      else
-        entries.set(name.toLowerCase(), [name, value]);
-  return Object.fromEntries(entries.values());
-};
-var bufferResponse = async (response, signal) => {
-  const reader = response.clone().body?.getReader();
-  if (!reader)
-    return;
-  const cancel = () => {
-    reader.cancel(signal.reason).catch(() => {});
-    response.body?.cancel(signal.reason).catch(() => {});
-  };
-  signal.addEventListener("abort", cancel, { once: true });
-  try {
-    if (signal.aborted)
-      cancel();
-    signal.throwIfAborted();
-    while (!(await reader.read()).done)
-      signal.throwIfAborted();
-    signal.throwIfAborted();
-  } finally {
-    signal.removeEventListener("abort", cancel);
-    reader.releaseLock();
-  }
-};
-var RUNTIME = describeRuntime();
-var TypeSafeClient = class {
-  #apiKey;
-  baseURL;
-  defaultModel;
-  logLevel;
-  logger;
-  retry;
-  timeout;
-  defaultHeaders;
-  fetch;
-  models;
-  #requestCount = 0;
-  constructor(config2 = {}) {
-    if (isBrowser() && !config2.dangerouslyAllowBrowser)
-      refuseBrowser();
-    this.#apiKey = fromCodeOrEnv(config2.apiKey, ENV.apiKey) ?? missingApiKey();
-    this.baseURL = stripTrailingSlashes(fromCodeOrEnv(config2.baseURL, ENV.baseURL) ?? "https://api.typesafe.ai");
-    this.defaultModel = fromCodeOrEnv(config2.defaultModel, ENV.defaultModel) ?? "jev-latest";
-    this.logLevel = resolveLogLevel(config2.logLevel);
-    this.logger = withLevel(config2.logger ?? consoleLogger, this.logLevel);
-    this.retry = resolveRetryPolicy(DEFAULT_RETRY_POLICY, config2.retry);
-    this.timeout = assertPositiveMs("timeout", config2.timeout ?? 1e4);
-    this.defaultHeaders = { ...config2.defaultHeaders };
-    if (config2.fetch === undefined && typeof globalThis.fetch !== "function")
-      missingFetch();
-    this.fetch = config2.fetch ?? defaultFetch;
-    const transport = {
-      request: (method, path, options) => this.#request(method, path, options),
-      defaultModel: this.defaultModel
-    };
-    this.models = new Models(transport);
-  }
-  systemOne(request, options = {}) {
-    validateQuestions(request.questions);
-    const body = {
-      ...request,
-      model: request.model ?? this.defaultModel
-    };
-    return this.#request("POST", "/v1/systemone", {
-      ...options,
-      body
-    });
+// ../../node_modules/.bun/@nimit9+signet-ai@0.1.11+a8a356da5edd5fb9/node_modules/@nimit9/signet-ai/dist/jev.js
+var JEV_DEFAULT_MODEL = "jev-1.13.0";
+var JEV_DEFAULT_MIN_CONFIDENCE = 0.95;
+var JEV_DEFAULT_TIMEOUT_MS = 8000;
+var JEV_DEFAULT_BASE_URL = "https://api.typesafe.ai";
+function fallbackOf(q2, reason, extra = {}) {
+  const d2 = { value: q2.fallback, confident: false, source: "fallback", reason };
+  if (extra.confidence !== undefined)
+    d2.confidence = extra.confidence;
+  if (extra.answer !== undefined)
+    d2.answer = extra.answer;
+  if (extra.probability !== undefined)
+    d2.probability = extra.probability;
+  return d2;
+}
+function labelsOf(options) {
+  return Array.isArray(options) ? [...options] : Object.keys(options);
+}
+function isUnit(n2) {
+  return typeof n2 === "number" && Number.isFinite(n2) && n2 >= 0 && n2 <= 1;
+}
+function validQuestion(q2) {
+  if (!q2 || typeof q2.question !== "string")
+    return false;
+  if (q2.type === "choice") {
+    const labels = labelsOf(q2.options);
+    return labels.length >= 1 && labels.length <= 255 && labels.includes(q2.fallback);
+  }
+  if (q2.type === "score") {
+    return Array.isArray(q2.levels) && q2.levels.length >= 2 && q2.levels.length <= 10;
+  }
+  return q2.type === "noul";
+}
+function toWire(q2) {
+  if (q2.type === "choice") {
+    const criteria = Array.isArray(q2.options) ? Object.fromEntries(q2.options.map((l2) => [l2, null])) : q2.options;
+    return { type: "choice", instructions: q2.question, criteria };
+  }
+  if (q2.type === "score")
+    return { type: "score", instructions: q2.question, criteria: q2.levels };
+  return { type: "noul", instructions: q2.question };
+}
+function judge(q2, raw, min) {
+  const a2 = raw;
+  if (!a2 || typeof a2 !== "object")
+    return fallbackOf(q2, "invalid_response");
+  if (q2.type === "noul") {
+    const p2 = a2.noul;
+    if (!isUnit(p2))
+      return fallbackOf(q2, "invalid_response");
+    const confidence2 = Math.max(p2, 1 - p2);
+    const answer2 = p2 >= 0.5;
+    if (confidence2 < min) {
+      return fallbackOf(q2, "low_confidence", { confidence: confidence2, answer: answer2, probability: p2 });
+    }
+    return { value: answer2, confident: true, source: "jev", confidence: confidence2, probability: p2 };
+  }
+  const confidence = a2.confidence;
+  if (!isUnit(confidence))
+    return fallbackOf(q2, "invalid_response");
+  let answer;
+  if (q2.type === "choice") {
+    if (typeof a2.choice !== "string" || !labelsOf(q2.options).includes(a2.choice)) {
+      return fallbackOf(q2, "invalid_response", { confidence });
+    }
+    answer = a2.choice;
+  } else {
+    const s2 = a2.score;
+    if (typeof s2 !== "number" || !Number.isFinite(s2) || s2 < 0 || s2 > q2.levels.length - 1) {
+      return fallbackOf(q2, "invalid_response", { confidence });
+    }
+    answer = s2;
   }
-  #request(method, path, options = {}) {
-    const resolved = {
-      method,
-      path,
-      body: options.body,
-      headers: mergeHeaders(this.defaultHeaders, options.headers ?? {}),
-      signal: options.signal,
-      timeout: options.timeout === undefined ? this.timeout : assertPositiveMs("timeout", options.timeout),
-      retry: resolveRetryPolicy(this.retry, options.retry)
-    };
-    const tag = `#${++this.#requestCount} ${method} ${path}`;
-    return new APIPromise(this.fetchWithRetries(tag, resolved), async (res) => {
-      const parsed = await parseBody(res);
-      this.logger.debug(`${tag} <- body`, parsed);
-      return parsed;
-    });
+  if (confidence < min)
+    return fallbackOf(q2, "low_confidence", { confidence, answer });
+  return { value: answer, confident: true, source: "jev", confidence };
+}
+
+class Timeout {
+}
+function createJev(config2) {
+  const apiKey = typeof config2.apiKey === "string" ? config2.apiKey.trim() : "";
+  const model = config2.model ?? JEV_DEFAULT_MODEL;
+  const floor = config2.minConfidence ?? JEV_DEFAULT_MIN_CONFIDENCE;
+  const timeoutMs = config2.timeoutMs ?? JEV_DEFAULT_TIMEOUT_MS;
+  const allowSensitive = config2.allowSensitive === true;
+  const url3 = `${(config2.baseUrl ?? JEV_DEFAULT_BASE_URL).replace(/\/+$/, "")}/v1/systemone`;
+  function emit(event) {
+    if (!config2.onEvent)
+      return;
+    try {
+      config2.onEvent(event);
+    } catch {}
   }
-  async fetchWithRetries(tag, req) {
-    const url3 = `${this.baseURL}${req.path}`;
-    const headers = mergeHeaders(req.headers, {
-      Authorization: `Bearer ${this.#apiKey}`,
-      Accept: "application/json",
-      "User-Agent": `typesafe-sdk/${VERSION2}`,
-      "X-TypeSafe-SDK": `typesafe-sdk/${VERSION2}`,
-      "X-TypeSafe-Runtime": RUNTIME,
-      "Content-Type": req.body === undefined ? undefined : "application/json",
-      "X-TypeSafe-Retry-Count": undefined
-    });
-    const body = req.body === undefined ? undefined : JSON.stringify(req.body);
-    for (let attempt = 0;; attempt++) {
-      const retriesLeft = req.retry.maxRetries - attempt;
-      const attemptHeaders = attempt === 0 ? headers : {
-        ...headers,
-        "X-TypeSafe-Retry-Count": String(attempt)
+  function finish(questions, decisions, meta3) {
+    const durationMs = Date.now() - meta3.started;
+    for (const [name, d2] of Object.entries(decisions)) {
+      const event = {
+        kind: questions[name].type,
+        name,
+        source: d2.source,
+        sensitive: meta3.sensitive,
+        model,
+        durationMs
       };
-      this.logger.debug(`${tag} -> ${url3}`, {
-        headers: redactHeaders(attemptHeaders),
-        body: req.body
-      });
-      const started = Date.now();
-      let res;
-      try {
-        res = await this.attempt(tag, url3, {
-          method: req.method,
-          headers: attemptHeaders,
-          body
-        }, req);
-      } catch (err) {
-        if (err instanceof APIUserAbortError || retriesLeft <= 0)
-          throw err;
-        if (!isRetryableError(err, req.retry))
-          throw err;
-        await this.backOff(tag, attempt, retriesLeft, err.message, undefined, req);
-        continue;
-      }
-      const requestId = requestIdFrom(res.headers);
-      this.logger.info(`${tag} <- ${res.status} in ${Date.now() - started}ms${requestId ? ` (request ${requestId})` : ""}`);
-      if (res.ok)
-        return res;
-      const errorBody = await parseBody(res);
-      this.logger.debug(`${tag} <- error body`, errorBody);
-      const error62 = APIError.fromResponse(res.status, errorBody, res.headers);
-      if (retriesLeft <= 0 || !isRetryableStatus(res.status, req.retry))
-        throw error62;
-      await this.backOff(tag, attempt, retriesLeft, `${res.status}`, res.headers, req);
+      if (d2.reason)
+        event.reason = d2.reason;
+      if (d2.confidence !== undefined)
+        event.confidence = d2.confidence;
+      if (meta3.status !== undefined && d2.reason === "http_error")
+        event.status = meta3.status;
+      emit(event);
     }
+    return decisions;
   }
-  async attempt(tag, url3, init, { signal, timeout }) {
-    const controller = new AbortController;
-    const abortFromCaller = () => controller.abort(signal?.reason);
-    if (signal?.aborted)
-      abortFromCaller();
-    signal?.addEventListener("abort", abortFromCaller, { once: true });
-    let timedOut = false;
-    const timer = setTimeout(() => {
-      timedOut = true;
-      controller.abort();
-    }, timeout);
+  async function run(questions, base) {
     const started = Date.now();
-    const elapsed = () => `${Date.now() - started}ms`;
+    const sensitive = base.sensitive === true;
+    const all2 = (reason, status2) => finish(questions, Object.fromEntries(Object.entries(questions).map(([n2, q2]) => [n2, fallbackOf(q2, reason)])), { sensitive, started, status: status2 });
+    if (base.sensitive !== false && !allowSensitive)
+      return all2("sensitive_not_allowed");
+    if (!apiKey)
+      return all2("no_key");
+    const min = base.minConfidence ?? floor;
+    const names = Object.keys(questions);
+    if (!isUnit(min) || names.length === 0 || !names.every((n2) => validQuestion(questions[n2]))) {
+      return all2("invalid_request");
+    }
+    if (base.signal?.aborted)
+      return all2("aborted");
+    const controller = new AbortController;
+    const onAbort = () => controller.abort();
+    base.signal?.addEventListener("abort", onAbort, { once: true });
+    let timer;
+    const timeout = new Promise((resolve) => {
+      timer = setTimeout(() => {
+        controller.abort();
+        resolve(new Timeout);
+      }, timeoutMs);
+    });
+    const doFetch = config2.fetch ?? ((u2, i2) => globalThis.fetch(u2, i2));
+    let status;
     try {
-      const response = await this.fetch(url3, {
-        ...init,
-        signal: controller.signal
-      });
-      await bufferResponse(response, controller.signal);
-      return response;
+      const request = (async () => {
+        const res = await doFetch(url3, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            Accept: "application/json",
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            model,
+            state: base.state,
+            questions: Object.fromEntries(names.map((n2) => [n2, toWire(questions[n2])]))
+          }),
+          signal: controller.signal
+        });
+        status = res.status;
+        if (!res.ok)
+          return { ok: false };
+        return { ok: true, body: await res.json() };
+      })();
+      const out = await Promise.race([request, timeout]);
+      if (out instanceof Timeout) {
+        request.catch(() => {});
+        return all2("timeout");
+      }
+      if (!out.ok)
+        return all2("http_error", status);
+      const answers = out.body?.answers;
+      if (!answers || typeof answers !== "object")
+        return all2("invalid_response");
+      return finish(questions, Object.fromEntries(names.map((n2) => [n2, judge(questions[n2], answers[n2], min)])), { sensitive, started });
     } catch (err) {
-      if (signal?.aborted) {
-        this.logger.info(`${tag} aborted by caller after ${elapsed()}`);
-        throw new APIUserAbortError(undefined, { cause: err });
-      }
-      if (timedOut) {
-        this.logger.info(`${tag} timed out after ${elapsed()}`);
-        throw new APITimeoutError(timeout, { cause: err });
-      }
-      this.logger.info(`${tag} connection error after ${elapsed()}`, err);
-      throw new APIConnectionError(err instanceof Error ? `Connection error: ${err.message}` : undefined, { cause: err });
+      if (base.signal?.aborted)
+        return all2("aborted");
+      if (status !== undefined)
+        return all2("invalid_response");
+      return all2(err?.name === "TimeoutError" ? "timeout" : "network_error");
     } finally {
       clearTimeout(timer);
-      signal?.removeEventListener("abort", abortFromCaller);
+      base.signal?.removeEventListener("abort", onAbort);
     }
   }
-  async backOff(tag, attempt, retriesLeft, reason, headers, { retry, signal }) {
-    const delay = retryDelayMs(attempt, headers, retry);
-    const nth = attempt + 1;
-    const total = attempt + retriesLeft;
-    this.logger.info(`${tag} retrying in ${delay}ms (retry ${nth}/${total}) after ${reason}`);
-    try {
-      await sleep3(delay, signal);
-    } catch (err) {
-      this.logger.info(`${tag} aborted by caller while waiting to retry`);
-      throw new APIUserAbortError(undefined, { cause: err });
-    }
+  function baseOf(args) {
+    return {
+      state: args.state,
+      sensitive: args.sensitive,
+      minConfidence: args.minConfidence,
+      signal: args.signal
+    };
   }
-};
-var parseBody = async (res) => {
-  const text = await res.text();
-  if (text.length === 0)
-    return;
-  if ((res.headers.get("content-type") ?? "").includes("application/json"))
-    try {
-      return JSON.parse(text);
-    } catch {
-      return text;
+  return {
+    enabled: apiKey.length > 0,
+    async choice(args) {
+      const q2 = {
+        type: "choice",
+        question: args.question,
+        options: args.options,
+        fallback: args.fallback
+      };
+      const { result } = await run({ result: q2 }, baseOf(args));
+      return result;
+    },
+    async score(args) {
+      const q2 = {
+        type: "score",
+        question: args.question,
+        levels: args.levels,
+        fallback: args.fallback
+      };
+      const { result } = await run({ result: q2 }, baseOf(args));
+      return result;
+    },
+    async noul(args) {
+      const q2 = { type: "noul", question: args.question, fallback: args.fallback };
+      const { result } = await run({ result: q2 }, baseOf(args));
+      return result;
+    },
+    async batch(args) {
+      return await run(args.questions, baseOf(args));
     }
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-};
+  };
+}
 
 // src/lib/jev-categorize.ts
 var JEV_MODEL = "jev-1.13.0";
@@ -60125,18 +59700,18 @@ function assertJevAllowed(crypto3, env2 = process.env) {
     throw new Error("JEV_API_KEY is not set — Jev categorization is off.");
   return key;
 }
-function makeJevClassifier(apiKey) {
-  const client = new TypeSafeClient({ apiKey, timeout: TIMEOUT_MS });
-  return async (state, options) => {
-    const { answers } = await client.systemOne({
-      model: JEV_MODEL,
-      state,
-      questions: {
-        category: choice("Which spending category best fits this bank transaction?", options)
-      }
-    });
-    return { choice: answers.category.choice, confidence: answers.category.confidence };
-  };
+function jevAllowSensitive(crypto3, env2) {
+  return crypto3 === undefined || env2.JEV_ALLOW_PRIVATE_MODE === "1";
+}
+function makeJev(apiKey, crypto3, env2 = process.env, fetchImpl) {
+  return createJev({
+    apiKey,
+    model: JEV_MODEL,
+    minConfidence: DEFAULT_MIN_CONFIDENCE,
+    timeoutMs: TIMEOUT_MS,
+    allowSensitive: jevAllowSensitive(crypto3, env2),
+    ...fetchImpl ? { fetch: fetchImpl } : {}
+  });
 }
 var UNSURE = "unsure";
 function optionsFor(type, index) {
@@ -60154,26 +59729,33 @@ function groupState(type, sample) {
   const dir = type === "credit" ? "Money received" : "Money paid out";
   return `${dir}. Bank narration: "${sample.slice(0, 80)}"`;
 }
-async function jevCategorize(client, crypto3, classify, opts = {}) {
+async function jevCategorize(client, crypto3, jev, opts = {}) {
   assertPrivateModeAllowed(crypto3, opts.env);
-  const min = opts.minConfidence ?? DEFAULT_MIN_CONFIDENCE;
   const index = await loadCategoryIndex(client);
   const rows = await fetchUncategorized(client, crypto3, opts);
   const groups = groupRows(rows);
-  const unparsed = groups.filter((g3) => g3.pattern === UNPARSED).length;
-  const candidates = groups.filter((g3) => g3.pattern !== UNPARSED);
+  const unparsed = groups.filter((g2) => g2.pattern === UNPARSED).length;
+  const candidates = groups.filter((g2) => g2.pattern !== UNPARSED);
   let errors3 = 0;
-  const suggestions = await mapLimit(candidates, CONCURRENCY, async (g3) => {
-    try {
-      const options = optionsFor(g3.type, index);
-      const sample = g3.rows[0].description;
-      const text = crypto3 ? g3.pattern : sample;
-      const r2 = await classify(groupState(g3.type, text), options);
-      return r2.choice in options ? { g: g3, ...r2 } : null;
-    } catch {
-      errors3 += 1;
-      return null;
+  const suggestions = await mapLimit(candidates, CONCURRENCY, async (g2) => {
+    const options = optionsFor(g2.type, index);
+    const sample = g2.rows[0].description;
+    const text = crypto3 ? g2.pattern : sample;
+    const d2 = await jev.choice({
+      question: "Which spending category best fits this bank transaction?",
+      options,
+      fallback: UNSURE,
+      state: groupState(g2.type, text),
+      sensitive: true,
+      minConfidence: opts.minConfidence
+    });
+    if (d2.confident)
+      return { g: g2, choice: d2.value, confidence: d2.confidence, confident: true };
+    if (d2.reason === "low_confidence" && d2.answer !== undefined) {
+      return { g: g2, choice: d2.answer, confidence: d2.confidence ?? 0, confident: false };
     }
+    errors3 += 1;
+    return null;
   });
   const accepted = [];
   const review = [];
@@ -60181,7 +59763,7 @@ async function jevCategorize(client, crypto3, classify, opts = {}) {
     if (!s2)
       continue;
     const isTransfer = index.bySlug.get(s2.choice)?.type === "transfer";
-    if (s2.choice !== UNSURE && !isTransfer && s2.confidence >= min) {
+    if (s2.confident && s2.choice !== UNSURE && !isTransfer) {
       accepted.push({
         pattern: s2.g.pattern,
         type: s2.g.type,
@@ -60230,7 +59812,8 @@ function jevTools(client, crypto3) {
       }),
       handler: async ({ startDate, endDate, minConfidence, dryRun }) => {
         const key = assertJevAllowed(crypto3);
-        const result = await jevCategorize(client, crypto3, makeJevClassifier(key), {
+        const jev = makeJev(key, crypto3);
+        const result = await jevCategorize(client, crypto3, jev, {
           startDate,
           endDate,
           minConfidence,
@@ -60268,15 +59851,7 @@ function settingsTools(client) {
     describe: { name: "", ownerLabels: "Owner slug → display name" },
     variants: { profile: profile.update, household: household.update }
   });
-  return [
-    get.tool,
-    update.tool,
-    get.alias("get_profile", "profile"),
-    get.alias("get_household", "household"),
-    get.alias("get_encryption_status", "encryption"),
-    update.alias("update_profile", "profile"),
-    update.alias("update_household", "household")
-  ];
+  return [get.tool, update.tool];
 }
 
 // src/tools/statement-import.ts
@@ -60562,15 +60137,7 @@ function statementImportTools(client, crypto3) {
       })
     }
   });
-  return [
-    preview.tool,
-    commit.tool,
-    aliasTool("import_statement_pdf", pdfInput.extend({ confirm: exports_external.boolean().optional() }), "preview_import / import_statement", 'from: "pdf" (confirm:true → import_statement, else preview_import)', ({ confirm, ...args }) => confirm ? [commit.tool, { ...args, from: "pdf" }] : [preview.tool, { ...args, from: "pdf" }]),
-    preview.alias("import_csv_parse", "csv"),
-    commit.alias("import_csv_confirm", "csv"),
-    commit.alias("import_statement_batch", "rows"),
-    commit.alias("import_statement_file", "json_file")
-  ];
+  return [preview.tool, commit.tool];
 }
 
 // src/registrations.ts
@@ -60715,7 +60282,7 @@ function registerResources(server, tools) {
 // package.json
 var package_default = {
   name: "paisa-mcp",
-  version: "0.2.0",
+  version: "0.3.0",
   repository: {
     type: "git",
     url: "git+https://github.com/nimit9/paisa.git",
@@ -60742,13 +60309,14 @@ var package_default = {
   devDependencies: {
     "@modelcontextprotocol/client": "^2.1.0",
     "@modelcontextprotocol/server": "^2.1.0",
+    "@nimit9/signet-ai": "^0.1.11",
+    "@nimit9/signet-lib": "^0.1.14",
     "@nimit9/signet-server": "^0.2.2",
     "@paisa/parsers": "workspace:*",
     "@paisa/reconciliation": "workspace:*",
     "@paisa/types": "workspace:*",
     "@scure/bip39": "^2.2.0",
     "@types/bun": "^1.3.14",
-    "@typesafe-ai/sdk": "^0.6.0",
     axios: "^1.16.1",
     "hash-wasm": "^4.12.0",
     typescript: "^7.0.2",
@@ -60760,7 +60328,7 @@ var package_default = {
 };
 
 // src/version.ts
-var VERSION3 = package_default.version;
+var VERSION2 = package_default.version;
 
 // src/server.ts
 function paisaErrorResult(err) {
@@ -60772,31 +60340,18 @@ function paisaErrorResult(err) {
 function buildServer(client, crypto3) {
   const tools = applyAnnotations(REGISTRATIONS.flatMap((group) => group.tools(client, crypto3)));
   for (const t2 of tools)
-    if (t2.input && !isAlias(t2))
+    if (t2.input)
       withCompactJsonSchema(t2.input);
   const server = createMcpServer({
     name: "paisa",
-    version: VERSION3,
+    version: VERSION2,
     tools,
     errorResult: paisaErrorResult
   });
-  hideFromToolsList(server, new Set(tools.filter(isAlias).map((t2) => t2.name)));
   registerResources(server, tools);
   registerPrompts(server);
   return server;
 }
-function hideFromToolsList(server, hidden) {
-  if (hidden.size === 0)
-    return;
-  const inner = server.server;
-  const list = inner._getRequestHandler("tools/list");
-  if (!list)
-    throw new Error("MCP SDK: no tools/list handler to wrap (aliases would be listed)");
-  server.server.setRequestHandler("tools/list", async (request, ctx) => {
-    const result = await list(request, ctx);
-    return { ...result, tools: result.tools.filter((t2) => !hidden.has(t2.name)) };
-  });
-}
 
 // src/index.ts
 async function main() {
@@ -60819,5 +60374,5 @@ main().catch((err) => {
   process.exit(1);
 });
 
-//# debugId=1E3042577A7AFC5F64756E2164756E21
+//# debugId=C64445D8B55EDCFA64756E2164756E21
 //# sourceMappingURL=index.js.map