@lucid-agents/taskmarket 1.16.0 → 1.17.0

package/dist/pi-extensions/xgate.cjs

@@ -0,0 +1,2260 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/.pnpm/tsup@8.5.1_tsx@4.21.0_typescript@5.7.3_yaml@2.8.1/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl, importMetaUrl;
+var init_cjs_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.1_tsx@4.21.0_typescript@5.7.3_yaml@2.8.1/node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+    getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+    importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+  }
+});
+
+// src/pi-extensions/xgate.ts
+var xgate_exports = {};
+__export(xgate_exports, {
+  default: () => taskmarketXgate
+});
+module.exports = __toCommonJS(xgate_exports);
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/@lucid-agents+pi-xgate@0.1.6_@earendil-works+pi-ai@0.85.1_@earendil-works+pi-coding-agent@0.8_344x6vs3jrzh5eh3xewwgv3ik4/node_modules/@lucid-agents/pi-xgate/dist/index.js
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/@lucid-agents+pi-xgate@0.1.6_@earendil-works+pi-ai@0.85.1_@earendil-works+pi-coding-agent@0.8_344x6vs3jrzh5eh3xewwgv3ik4/node_modules/@lucid-agents/pi-xgate/dist/provider.js
+init_cjs_shims();
+var import_node_crypto2 = require("crypto");
+var import_pi_ai = require("@earendil-works/pi-ai");
+
+// ../../node_modules/.pnpm/@lucid-agents+xgate-client@0.1.6_@solana+sysvars@5.5.1_typescript@5.7.3_zod@3.25.76/node_modules/@lucid-agents/xgate-client/dist/types.js
+init_cjs_shims();
+var XgateError = class extends Error {
+  code;
+  constructor(code) {
+    super(`Xgate: ${code}. Inspect /xgate status before another purchase.`);
+    this.name = "XgateError";
+    this.code = code;
+  }
+};
+function requireValue(condition, code) {
+  if (!condition)
+    throw new XgateError(code);
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function origin(value, loopback = false) {
+  const u = new URL(value);
+  requireValue((u.protocol === "https:" || loopback && u.protocol === "http:" && ["127.0.0.1", "[::1]"].includes(u.hostname)) && !u.username && !u.password && u.pathname === "/" && !u.search && !u.hash, "invalid_origin");
+  return u.origin;
+}
+
+// ../../node_modules/.pnpm/@lucid-agents+pi-xgate@0.1.6_@earendil-works+pi-ai@0.85.1_@earendil-works+pi-coding-agent@0.8_344x6vs3jrzh5eh3xewwgv3ik4/node_modules/@lucid-agents/pi-xgate/dist/codec.js
+init_cjs_shims();
+var pi = __toESM(require("@earendil-works/pi-ai"), 1);
+
+// ../../node_modules/.pnpm/@lucid-agents+pi-xgate@0.1.6_@earendil-works+pi-ai@0.85.1_@earendil-works+pi-coding-agent@0.8_344x6vs3jrzh5eh3xewwgv3ik4/node_modules/@lucid-agents/pi-xgate/dist/generated/openai-model-capabilities.json
+var openai_model_capabilities_default = {
+  "gpt-5": {
+    canonical: "gpt-5",
+    price_label: "gpt-5",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "minimal",
+      "low",
+      "medium",
+      "high"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5",
+      "gpt-5-2025-08-07"
+    ]
+  },
+  "gpt-5-2025-08-07": {
+    canonical: "gpt-5",
+    price_label: "gpt-5",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "minimal",
+      "low",
+      "medium",
+      "high"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5-2025-08-07"
+    ]
+  },
+  "gpt-5-chat-latest": {
+    canonical: "gpt-5-chat-latest",
+    price_label: "gpt-5-chat-latest",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5-chat-latest"
+    ]
+  },
+  "gpt-5-codex": {
+    canonical: "gpt-5-codex",
+    price_label: "gpt-5-codex",
+    operations: [
+      "responses"
+    ],
+    reasoning_efforts: [],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5-codex"
+    ]
+  },
+  "gpt-5-mini": {
+    canonical: "gpt-5-mini",
+    price_label: "gpt-5-mini",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "minimal"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5-mini",
+      "gpt-5-mini-2025-08-07"
+    ]
+  },
+  "gpt-5-mini-2025-08-07": {
+    canonical: "gpt-5-mini",
+    price_label: "gpt-5-mini",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "minimal"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5-mini-2025-08-07"
+    ]
+  },
+  "gpt-5-nano": {
+    canonical: "gpt-5-nano",
+    price_label: "gpt-5-nano",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "minimal",
+      "low",
+      "medium",
+      "high"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5-nano",
+      "gpt-5-nano-2025-08-07"
+    ]
+  },
+  "gpt-5-nano-2025-08-07": {
+    canonical: "gpt-5-nano",
+    price_label: "gpt-5-nano",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "minimal",
+      "low",
+      "medium",
+      "high"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5-nano-2025-08-07"
+    ]
+  },
+  "gpt-5-pro": {
+    canonical: "gpt-5-pro",
+    price_label: "gpt-5-pro",
+    operations: [
+      "responses"
+    ],
+    reasoning_efforts: [
+      "high"
+    ],
+    cache: "uncached",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5-pro",
+      "gpt-5-pro-2025-10-06"
+    ]
+  },
+  "gpt-5-pro-2025-10-06": {
+    canonical: "gpt-5-pro",
+    price_label: "gpt-5-pro",
+    operations: [
+      "responses"
+    ],
+    reasoning_efforts: [
+      "high"
+    ],
+    cache: "uncached",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5-pro-2025-10-06"
+    ]
+  },
+  "gpt-5.1": {
+    canonical: "gpt-5.1",
+    price_label: "gpt-5.1",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.1",
+      "gpt-5.1-2025-11-13"
+    ]
+  },
+  "gpt-5.1-2025-11-13": {
+    canonical: "gpt-5.1",
+    price_label: "gpt-5.1",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.1-2025-11-13"
+    ]
+  },
+  "gpt-5.1-chat-latest": {
+    canonical: "gpt-5.1-chat-latest",
+    price_label: "gpt-5.1-chat-latest",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.1-chat-latest"
+    ]
+  },
+  "gpt-5.1-codex": {
+    canonical: "gpt-5.1-codex",
+    price_label: "gpt-5.1-codex",
+    operations: [
+      "responses"
+    ],
+    reasoning_efforts: [],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.1-codex"
+    ]
+  },
+  "gpt-5.1-codex-max": {
+    canonical: "gpt-5.1-codex-max",
+    price_label: "gpt-5.1-codex-max",
+    operations: [
+      "responses"
+    ],
+    reasoning_efforts: [],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.1-codex-max"
+    ]
+  },
+  "gpt-5.1-codex-mini": {
+    canonical: "gpt-5.1-codex-mini",
+    price_label: "gpt-5.1-codex-mini",
+    operations: [
+      "responses"
+    ],
+    reasoning_efforts: [],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.1-codex-mini"
+    ]
+  },
+  "gpt-5.2": {
+    canonical: "gpt-5.2",
+    price_label: "gpt-5.2",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.2",
+      "gpt-5.2-2025-12-11"
+    ]
+  },
+  "gpt-5.2-2025-12-11": {
+    canonical: "gpt-5.2",
+    price_label: "gpt-5.2",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.2-2025-12-11"
+    ]
+  },
+  "gpt-5.2-chat-latest": {
+    canonical: "gpt-5.2-chat-latest",
+    price_label: "gpt-5.2-chat-latest",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.2-chat-latest"
+    ]
+  },
+  "gpt-5.2-codex": {
+    canonical: "gpt-5.2-codex",
+    price_label: "gpt-5.2-codex",
+    operations: [
+      "responses"
+    ],
+    reasoning_efforts: [],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.2-codex"
+    ]
+  },
+  "gpt-5.2-pro": {
+    canonical: "gpt-5.2-pro",
+    price_label: "gpt-5.2-pro",
+    operations: [
+      "responses"
+    ],
+    reasoning_efforts: [
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "uncached",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.2-pro",
+      "gpt-5.2-pro-2025-12-11"
+    ]
+  },
+  "gpt-5.2-pro-2025-12-11": {
+    canonical: "gpt-5.2-pro",
+    price_label: "gpt-5.2-pro",
+    operations: [
+      "responses"
+    ],
+    reasoning_efforts: [
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "uncached",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.2-pro-2025-12-11"
+    ]
+  },
+  "gpt-5.3-chat-latest": {
+    canonical: "gpt-5.3-chat-latest",
+    price_label: "gpt-5.3-chat-latest",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.3-chat-latest"
+    ]
+  },
+  "gpt-5.3-codex": {
+    canonical: "gpt-5.3-codex",
+    price_label: "gpt-5.3-codex",
+    operations: [
+      "responses"
+    ],
+    reasoning_efforts: [
+      "low",
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.3-codex"
+    ]
+  },
+  "gpt-5.4": {
+    canonical: "gpt-5.4",
+    price_label: "gpt-5.4 (<272K context length)",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.4",
+      "gpt-5.4-2026-03-05"
+    ]
+  },
+  "gpt-5.4-2026-03-05": {
+    canonical: "gpt-5.4",
+    price_label: "gpt-5.4 (<272K context length)",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.4-2026-03-05"
+    ]
+  },
+  "gpt-5.4-mini": {
+    canonical: "gpt-5.4-mini",
+    price_label: "gpt-5.4-mini",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.4-mini",
+      "gpt-5.4-mini-2026-03-17"
+    ]
+  },
+  "gpt-5.4-mini-2026-03-17": {
+    canonical: "gpt-5.4-mini",
+    price_label: "gpt-5.4-mini",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.4-mini-2026-03-17"
+    ]
+  },
+  "gpt-5.4-nano": {
+    canonical: "gpt-5.4-nano",
+    price_label: "gpt-5.4-nano",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.4-nano",
+      "gpt-5.4-nano-2026-03-17"
+    ]
+  },
+  "gpt-5.4-nano-2026-03-17": {
+    canonical: "gpt-5.4-nano",
+    price_label: "gpt-5.4-nano",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.4-nano-2026-03-17"
+    ]
+  },
+  "gpt-5.4-pro": {
+    canonical: "gpt-5.4-pro",
+    price_label: "gpt-5.4-pro (<272K context length)",
+    operations: [
+      "responses"
+    ],
+    reasoning_efforts: [
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "uncached",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.4-pro",
+      "gpt-5.4-pro-2026-03-05"
+    ]
+  },
+  "gpt-5.4-pro-2026-03-05": {
+    canonical: "gpt-5.4-pro",
+    price_label: "gpt-5.4-pro (<272K context length)",
+    operations: [
+      "responses"
+    ],
+    reasoning_efforts: [
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "uncached",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.4-pro-2026-03-05"
+    ]
+  },
+  "gpt-5.5": {
+    canonical: "gpt-5.5",
+    price_label: "gpt-5.5 (<272K context length)",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.5",
+      "gpt-5.5-2026-04-23"
+    ]
+  },
+  "gpt-5.5-2026-04-23": {
+    canonical: "gpt-5.5",
+    price_label: "gpt-5.5 (<272K context length)",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "implicit",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.5-2026-04-23"
+    ]
+  },
+  "gpt-5.5-pro": {
+    canonical: "gpt-5.5-pro",
+    price_label: "gpt-5.5-pro (<272K context length)",
+    operations: [
+      "responses"
+    ],
+    reasoning_efforts: [
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "uncached",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.5-pro",
+      "gpt-5.5-pro-2026-04-23"
+    ]
+  },
+  "gpt-5.5-pro-2026-04-23": {
+    canonical: "gpt-5.5-pro",
+    price_label: "gpt-5.5-pro (<272K context length)",
+    operations: [
+      "responses"
+    ],
+    reasoning_efforts: [
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    cache: "uncached",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.5-pro-2026-04-23"
+    ]
+  },
+  "gpt-5.6": {
+    canonical: "gpt-5.6-sol",
+    price_label: "gpt-5.6-sol",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max"
+    ],
+    cache: "write_priced",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.6",
+      "gpt-5.6-sol"
+    ]
+  },
+  "gpt-5.6-luna": {
+    canonical: "gpt-5.6-luna",
+    price_label: "gpt-5.6-luna",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max"
+    ],
+    cache: "write_priced",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.6-luna"
+    ]
+  },
+  "gpt-5.6-sol": {
+    canonical: "gpt-5.6-sol",
+    price_label: "gpt-5.6-sol",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max"
+    ],
+    cache: "write_priced",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.6-sol"
+    ]
+  },
+  "gpt-5.6-terra": {
+    canonical: "gpt-5.6-terra",
+    price_label: "gpt-5.6-terra",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max"
+    ],
+    cache: "write_priced",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-5.6-terra"
+    ]
+  },
+  "gpt-6-astra": {
+    canonical: "gpt-6-astra",
+    price_label: "gpt-6-astra",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max"
+    ],
+    cache: "write_priced",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-6-astra"
+    ],
+    chat_tools: "unsupported"
+  },
+  "gpt-6-sol": {
+    canonical: "gpt-6-sol",
+    price_label: "gpt-6-sol",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max"
+    ],
+    cache: "write_priced",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-6-sol"
+    ],
+    chat_tools: "reasoning_none"
+  },
+  "gpt-6-luna": {
+    canonical: "gpt-6-luna",
+    price_label: "gpt-6-luna",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max"
+    ],
+    cache: "write_priced",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-6-luna"
+    ],
+    chat_tools: "reasoning_none"
+  },
+  "gpt-6.1-sol": {
+    canonical: "gpt-6.1-sol",
+    price_label: "gpt-6.1-sol",
+    operations: [
+      "chat",
+      "responses"
+    ],
+    reasoning_efforts: [
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max"
+    ],
+    cache: "write_priced",
+    tools: true,
+    chat_legacy_max_tokens: false,
+    response_models: [
+      "gpt-6.1-sol"
+    ],
+    chat_tools: "unsupported"
+  }
+};
+
+// ../../node_modules/.pnpm/@lucid-agents+pi-xgate@0.1.6_@earendil-works+pi-ai@0.85.1_@earendil-works+pi-coding-agent@0.8_344x6vs3jrzh5eh3xewwgv3ik4/node_modules/@lucid-agents/pi-xgate/dist/codec.js
+var import_node_crypto = require("crypto");
+var need = (x, code) => {
+  if (!x)
+    throw new XgateError(code);
+};
+var object = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
+var rate = (x) => {
+  need(x && typeof x.numerator === "string" && /^[0-9]{1,13}$/.test(x.numerator) && Number(x.numerator) <= 1e12 && Number.isSafeInteger(x.denominator) && x.denominator > 0 && x.denominator <= 1e6, "invalid_catalog_rate");
+  return Number(x.numerator) / x.denominator;
+};
+function catalogEntries(rows) {
+  need(Array.isArray(rows) && rows.length <= 128, "invalid_catalog");
+  const entries = [];
+  for (const row of rows) {
+    const p = row?.execution_profile;
+    if (!object(p) || p.model !== row.id || !Array.isArray(row.qualified_profiles))
+      continue;
+    const anthropic = row.owned_by === "anthropic", cap = anthropic ? p.capabilities : openai_model_capabilities_default[row.id];
+    if (!cap || !anthropic && !cap.tools)
+      continue;
+    const op = anthropic ? "messages" : "responses";
+    const q = row.qualified_profiles.find((q2) => q2.model === row.id && q2.operation === op && q2.provider === (anthropic ? "anthropic" : "open_ai") && q2.normalizer_revision === (anthropic ? "anthropic-anonymous-usage-v3" : "openai-anonymous-usage-v1") && q2.transformation_revision === (anthropic ? "anthropic-anonymous-messages-v1" : "openai-anonymous-tools-v2"));
+    if (!q || row.privacy?.revision !== "anonymous-volatile-v1" || row.privacy.result_replay_available !== false || anthropic && q.cache_mode !== "anthropic_no_cache")
+      continue;
+    if (q.valid_until !== void 0 && Number(q.valid_until) * 1e3 <= Date.now())
+      continue;
+    if (row.lifecycle?.stop_before != null && Number(row.lifecycle.stop_before) * 1e3 <= Date.now())
+      continue;
+    const contextWindow = Math.min(p.max_input_tokens, p.provider_limits?.context_window ?? cap.context_window ?? p.max_input_tokens), maxTokens = Math.min(8192, p.max_output_tokens);
+    need(Number.isSafeInteger(contextWindow) && contextWindow > 0 && Number.isSafeInteger(maxTokens) && maxTokens > 0, "invalid_catalog_limits");
+    const efforts = anthropic ? cap.effort : cap.reasoning_efforts;
+    const levels = [
+      "minimal",
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max"
+    ];
+    const thinkingLevelMap = {
+      off: anthropic ? cap.thinking.disabled ? "disabled" : null : efforts.length === 0 || efforts.includes("none") ? "none" : null
+    };
+    for (const level of levels) {
+      const allowed = efforts.includes(level) || anthropic && cap.thinking.enabled && ["minimal", "low", "medium", "high"].includes(level);
+      thinkingLevelMap[level] = allowed ? level : null;
+    }
+    entries.push({
+      catalog: row,
+      route: anthropic ? "/providers/anthropic/v1/messages" : "/providers/openai/v1/responses",
+      efforts,
+      model: {
+        id: row.id,
+        name: `${row.id} (xgate)`,
+        api: anthropic ? "xgate-messages" : "xgate-responses",
+        provider: "xgate",
+        baseUrl: row.xgate_origin ?? "https://api.xgate.run",
+        input: ["text"],
+        contextWindow,
+        maxTokens,
+        reasoning: anthropic ? Boolean(cap.thinking?.adaptive || cap.thinking?.enabled) : efforts.some((effort) => effort !== "none"),
+        thinkingLevelMap,
+        cost: {
+          input: rate(p.rates.input_uncached),
+          output: rate(p.rates.output),
+          cacheRead: rate(p.rates.input_cache_read),
+          cacheWrite: p.rates.input_cache_write ? rate(p.rates.input_cache_write) : 0
+        },
+        inputLimits: { maxRequestBytes: 8 * 1024 * 1024 }
+      }
+    });
+  }
+  return entries;
+}
+function transcript(context) {
+  const legacy = "systemPrompt" in context || "tools" in context;
+  if (typeof pi.collapseSystemMessages !== "function") {
+    need(!context.messages.some((m) => m.role === "system"), "unsupported_context");
+    const raw = context;
+    return {
+      system: raw.systemPrompt ?? "",
+      tools: raw.tools ?? [],
+      messages: raw.messages
+    };
+  }
+  const collapsed = pi.collapseSystemMessages(legacy ? pi.normalizeContext(context) : context);
+  return {
+    system: pi.getCurrentSystemPrompt(collapsed.messages),
+    tools: pi.getCurrentTools(collapsed.messages),
+    messages: collapsed.messages.filter((m) => m.role !== "system")
+  };
+}
+function text(content) {
+  if (typeof content === "string")
+    return content;
+  need(Array.isArray(content) && content.every((b) => b.type === "text" && typeof b.text === "string"), "text_only_request");
+  return content.map((b) => b.text).join("\n");
+}
+function callId(id) {
+  return /^[A-Za-z0-9_:.\-]{1,128}$/.test(id) ? id : "call_" + (0, import_node_crypto.createHash)("sha256").update(id).digest("hex").slice(0, 40);
+}
+function validateTools(tools, anthropic) {
+  need(tools.length <= (anthropic ? 32 : 8), "too_many_tools");
+  need(tools.every((t) => /^[A-Za-z0-9_-]{1,64}$/.test(t.name) && object(t.parameters) && t.parameters.type === "object"), "unsupported_tool_schema");
+  need(new Set(tools.map((t) => t.name)).size === tools.length, "duplicate_tools");
+}
+function encode(entry, context, options = {}) {
+  need(options.toolChoice === void 0 || options.toolChoice === "auto", "unsupported_tool_choice");
+  need(options.reasoning === void 0 || typeof options.reasoning === "string", "unsupported_reasoning");
+  need(options.temperature === void 0 && (!options.samplingParams || Object.keys(options.samplingParams).length === 0), "unsupported_sampling");
+  const anthropic = entry.route.endsWith("/messages"), { system, tools, messages } = transcript(context);
+  validateTools(tools, anthropic);
+  const max = options.maxTokens ?? Math.min(4096, entry.model.maxTokens);
+  need(Number.isSafeInteger(max) && max > 0 && max <= entry.model.maxTokens, "output_limit");
+  const requested = options.reasoning, effort = requested && entry.efforts.includes(requested) ? requested : entry.efforts[0];
+  if (requested)
+    need(entry.model.thinkingLevelMap?.[requested] !== null && (entry.efforts.includes(requested) || anthropic && entry.catalog.execution_profile.capabilities.thinking.enabled), "unsupported_reasoning");
+  const history = [];
+  const append = (role, content) => {
+    const previous = history.at(-1);
+    if (previous?.role === role)
+      previous.content.push(...content);
+    else
+      history.push({ role, content });
+  };
+  if (!anthropic && system)
+    history.push({ role: "system", content: system });
+  for (const message of messages) {
+    if (message.role === "user") {
+      const value = text(message.content);
+      if (anthropic)
+        append("user", [{ type: "text", text: value }]);
+      else
+        history.push({ role: "user", content: value });
+      continue;
+    }
+    if (message.role === "toolResult") {
+      const value = text(message.content), id = callId(message.toolCallId);
+      if (anthropic)
+        append("user", [
+          {
+            type: "tool_result",
+            tool_use_id: id,
+            content: value,
+            ...message.isError ? { is_error: true } : {}
+          }
+        ]);
+      else
+        history.push({
+          type: "function_call_output",
+          call_id: id,
+          output: message.isError ? "Tool error: " + value : value
+        });
+      continue;
+    }
+    need(message.role === "assistant", "unsupported_message");
+    if (message.stopReason === "error" || message.stopReason === "aborted")
+      continue;
+    const same = message.provider === "xgate" && message.model === entry.model.id && message.api === entry.model.api;
+    const blocks = [];
+    for (const block of message.content) {
+      if (block.type === "text") {
+        if (anthropic) {
+          if (block.text)
+            blocks.push({ type: "text", text: block.text });
+        } else if (block.text) {
+          let signature;
+          try {
+            signature = block.textSignature ? JSON.parse(block.textSignature) : void 0;
+          } catch {
+          }
+          const previous = history.at(-1);
+          if (same && signature?.id && previous?.type === "message" && previous.id === signature.id && previous.phase === signature.phase) {
+            previous.content.push({ type: "output_text", text: block.text });
+            continue;
+          }
+          history.push({
+            type: "message",
+            role: "assistant",
+            content: [{ type: "output_text", text: block.text }],
+            ...same && signature?.id ? {
+              id: signature.id,
+              ...signature.phase ? { phase: signature.phase } : {}
+            } : {}
+          });
+        }
+      } else if (block.type === "toolCall") {
+        need(!block.namespace && object(block.arguments), "unsupported_tool_call");
+        const id = callId(block.id);
+        if (anthropic) {
+          need(tools.some((t) => t.name === block.name), "history_tool_not_declared");
+          blocks.push({
+            type: "tool_use",
+            id,
+            name: block.name,
+            input: block.arguments
+          });
+        } else
+          history.push({
+            type: "function_call",
+            call_id: id,
+            name: block.name,
+            arguments: JSON.stringify(block.arguments)
+          });
+      } else if (block.type === "thinking" && same) {
+        if (anthropic) {
+          need(typeof block.thinkingSignature === "string" && block.thinkingSignature.length > 0, "missing_thinking_signature");
+          blocks.push(block.redacted ? { type: "redacted_thinking", data: block.thinkingSignature } : {
+            type: "thinking",
+            thinking: block.thinking,
+            signature: block.thinkingSignature
+          });
+        } else if (block.thinkingSignature) {
+          const reasoning = JSON.parse(block.thinkingSignature);
+          need(reasoning.type === "reasoning" && typeof reasoning.encrypted_content === "string", "invalid_reasoning_history");
+          history.push(reasoning);
+        }
+      }
+    }
+    if (anthropic && blocks.length)
+      append("assistant", blocks);
+  }
+  need(history.length > 0 && history.length <= 256, "history_limit");
+  let request;
+  if (anthropic) {
+    const cap = entry.catalog.execution_profile.capabilities;
+    request = {
+      model: entry.model.id,
+      messages: history,
+      max_tokens: max,
+      stream: false,
+      ...system ? { system } : {},
+      ...tools.length ? {
+        tools: tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          input_schema: t.parameters
+        }))
+      } : {}
+    };
+    if (effort)
+      request.output_config = { effort };
+    if (cap.thinking.adaptive)
+      request.thinking = { type: "adaptive" };
+    else if (requested && cap.thinking.enabled) {
+      need(max > 1024, "thinking_output_limit");
+      request.thinking = {
+        type: "enabled",
+        budget_tokens: Math.min(2048, max - 1)
+      };
+    }
+  } else
+    request = {
+      model: entry.model.id,
+      input: history,
+      max_output_tokens: max,
+      stream: false,
+      store: false,
+      include: ["reasoning.encrypted_content"],
+      ...effort ? { reasoning: { effort } } : {},
+      ...tools.length ? {
+        tools: tools.map((t) => ({
+          type: "function",
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters
+        })),
+        parallel_tool_calls: false
+      } : {}
+    };
+  if (request.tools)
+    need(Buffer.byteLength(JSON.stringify(request.tools)) <= (anthropic ? 65536 : 8192), "tool_schema_bound");
+  need(Buffer.byteLength(JSON.stringify(request)) <= 8 * 1024 * 1024, "request_bound");
+  return request;
+}
+function tokens(value) {
+  need(Number.isSafeInteger(value) && value >= 0, "invalid_usage");
+  return value;
+}
+function decode(entry, body) {
+  need(object(body) && typeof body.id === "string" && object(body.usage), "invalid_result");
+  const anthropic = entry.route.endsWith("/messages"), content = [];
+  let stopReason;
+  if (anthropic) {
+    need(body.type === "message" && body.role === "assistant" && body.model === entry.model.id && ["end_turn", "tool_use", "stop_sequence"].includes(body.stop_reason) && Array.isArray(body.content), "invalid_result");
+    stopReason = body.stop_reason === "tool_use" ? "toolUse" : "stop";
+    for (const b of body.content) {
+      if (b.type === "text") {
+        need(typeof b.text === "string", "invalid_text");
+        content.push({ type: "text", text: b.text });
+      } else if (b.type === "tool_use") {
+        need(typeof b.id === "string" && typeof b.name === "string" && object(b.input), "invalid_tool_result");
+        content.push({
+          type: "toolCall",
+          id: b.id,
+          name: b.name,
+          arguments: b.input
+        });
+      } else if (b.type === "thinking") {
+        need(typeof b.thinking === "string" && typeof b.signature === "string", "invalid_thinking");
+        content.push({
+          type: "thinking",
+          thinking: b.thinking,
+          thinkingSignature: b.signature
+        });
+      } else if (b.type === "redacted_thinking") {
+        need(typeof b.data === "string", "invalid_thinking");
+        content.push({
+          type: "thinking",
+          thinking: "",
+          thinkingSignature: b.data,
+          redacted: true
+        });
+      } else
+        throw new XgateError("unsupported_result_block");
+    }
+  } else {
+    const cap = openai_model_capabilities_default[entry.model.id];
+    need(cap.response_models.includes(body.model) && body.status === "completed" && !body.error && !body.incomplete_details && Array.isArray(body.output), "invalid_result");
+    stopReason = "stop";
+    for (const b of body.output) {
+      if (b.type === "message") {
+        need(b.status === "completed" && Array.isArray(b.content), "invalid_result");
+        for (const t of b.content) {
+          need(t.type === "output_text" && typeof t.text === "string", "invalid_text");
+          content.push({
+            type: "text",
+            text: t.text,
+            ...b.id ? {
+              textSignature: JSON.stringify({
+                v: 1,
+                id: b.id,
+                ...b.phase ? { phase: b.phase } : {}
+              })
+            } : {}
+          });
+        }
+      } else if (b.type === "function_call") {
+        need(typeof b.call_id === "string" && typeof b.name === "string" && typeof b.arguments === "string", "invalid_tool_result");
+        const args = JSON.parse(b.arguments);
+        need(object(args), "invalid_tool_result");
+        content.push({
+          type: "toolCall",
+          id: b.call_id,
+          name: b.name,
+          arguments: args
+        });
+        stopReason = "toolUse";
+      } else if (b.type === "reasoning") {
+        need(Array.isArray(b.summary), "invalid_thinking");
+        const summary = b.summary.map((s) => {
+          need(s.type === "summary_text" && typeof s.text === "string", "invalid_thinking");
+          return s.text;
+        }).join("\n");
+        need(typeof b.encrypted_content === "string" && b.encrypted_content.length > 0, "missing_encrypted_reasoning");
+        content.push({
+          type: "thinking",
+          thinking: summary,
+          thinkingSignature: JSON.stringify({
+            type: "reasoning",
+            id: b.id,
+            summary: b.summary,
+            encrypted_content: b.encrypted_content,
+            ...b.status === "completed" ? { status: b.status } : {}
+          })
+        });
+      } else
+        throw new XgateError("unsupported_result_block");
+    }
+  }
+  need(content.some((c) => c.type === "text" && c.text.length > 0 || c.type === "toolCall"), "empty_result");
+  need(stopReason === "toolUse" === content.some((c) => c.type === "toolCall"), "tool_stop_mismatch");
+  const u = body.usage, read = tokens(anthropic ? u.cache_read_input_tokens ?? 0 : u.input_tokens_details?.cached_tokens), write = tokens(anthropic ? u.cache_creation_input_tokens ?? 0 : u.input_tokens_details?.cache_write_tokens ?? 0), totalInput = tokens(u.input_tokens), output = tokens(u.output_tokens), input = anthropic ? totalInput : totalInput - read - write;
+  need(input >= 0 && (!anthropic || read === 0 && write === 0), "cache_usage_mismatch");
+  const rates = entry.model.cost;
+  const cost = {
+    input: input * rates.input / 1e6,
+    output: output * rates.output / 1e6,
+    cacheRead: read * rates.cacheRead / 1e6,
+    cacheWrite: write * rates.cacheWrite / 1e6,
+    total: 0
+  };
+  cost.total = cost.input + cost.output + cost.cacheRead + cost.cacheWrite;
+  return {
+    content,
+    usage: {
+      input,
+      output,
+      cacheRead: read,
+      cacheWrite: write,
+      totalTokens: input + read + write + output,
+      cost
+    },
+    stopReason,
+    responseId: body.id
+  };
+}
+
+// ../../node_modules/.pnpm/@lucid-agents+pi-xgate@0.1.6_@earendil-works+pi-ai@0.85.1_@earendil-works+pi-coding-agent@0.8_344x6vs3jrzh5eh3xewwgv3ik4/node_modules/@lucid-agents/pi-xgate/dist/transport.js
+init_cjs_shims();
+var XgatePurchaseError = class extends XgateError {
+  invocationId;
+  pending;
+  payment;
+  constructor(code, invocationId2, pending, payment) {
+    super(code);
+    this.name = "XgatePurchaseError";
+    this.message = pending ? `Xgate: ${code}. The payment outcome is unknown; do not retry. Reconcile it before another purchase.` : `Xgate: ${code}. Inspect the payment status before another purchase.`;
+    this.invocationId = invocationId2;
+    this.pending = pending;
+    if (payment)
+      this.payment = payment;
+  }
+};
+
+// ../../node_modules/.pnpm/@lucid-agents+pi-xgate@0.1.6_@earendil-works+pi-ai@0.85.1_@earendil-works+pi-coding-agent@0.8_344x6vs3jrzh5eh3xewwgv3ik4/node_modules/@lucid-agents/pi-xgate/dist/provider.js
+var hash = (value) => (0, import_node_crypto2.createHash)("sha256").update(value).digest("hex");
+var zero = () => ({
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  totalTokens: 0,
+  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+});
+function invocationId(model, context, session) {
+  const legacy = "systemPrompt" in context || "tools" in context ? { systemPrompt: context.systemPrompt, tools: context.tools } : {};
+  return hash(JSON.stringify({
+    session,
+    model,
+    messages: context.messages.filter((m) => m.role !== "assistant" || !["error", "aborted"].includes(m.stopReason)),
+    ...legacy
+  }));
+}
+async function createXgateProvider(transport, { sessionId: identity = () => "standalone", onPaid, onPurchaseFailed } = {}) {
+  let entries = catalogEntries(await transport.models());
+  const stream = (model, context, options = {}) => {
+    const events = (0, import_pi_ai.createAssistantMessageEventStream)();
+    const timeout = options.timeoutMs ?? 18e4;
+    if (!Number.isSafeInteger(timeout) || timeout <= 0 || timeout > 18e4)
+      options = { ...options, timeoutMs: 18e4 };
+    const deadline = AbortSignal.timeout(Math.min(options.timeoutMs ?? 18e4, 18e4));
+    options = {
+      ...options,
+      signal: options.signal ? AbortSignal.any([options.signal, deadline]) : deadline
+    };
+    const message = {
+      role: "assistant",
+      provider: "xgate",
+      api: model.api,
+      model: model.id,
+      content: [],
+      usage: zero(),
+      stopReason: "pending",
+      timestamp: Date.now()
+    };
+    let attempted, paid;
+    void (async () => {
+      try {
+        options.signal?.throwIfAborted();
+        const current = catalogEntries(await transport.models(options.signal)), entry = current.find((e) => e.model.id === model.id && e.model.api === model.api);
+        if (!entry)
+          throw new XgateError("model_not_qualified");
+        const original = encode(entry, context, {
+          ...options,
+          // Respect a lower Pi model override without exceeding live catalog limits.
+          maxTokens: options.maxTokens ?? Math.min(4096, model.maxTokens, entry.model.maxTokens)
+        }), replacement = await options.onPayload?.(structuredClone(original), model), payload = replacement === void 0 ? original : replacement;
+        const limit = entry.route.endsWith("/messages") ? "max_tokens" : "max_output_tokens";
+        if (!payload || payload.model !== model.id || payload.stream !== false || payload[limit] !== original[limit] || JSON.stringify(payload.tools) !== JSON.stringify(original.tools) || !entry.route.endsWith("/messages") && payload.store !== false)
+          throw new XgateError("payload_hook_changed_scope");
+        const body = JSON.stringify(payload);
+        if (Buffer.byteLength(body) > 8 * 1024 * 1024)
+          throw new XgateError("request_bound");
+        const id = invocationId(model.id, context, options.sessionId ?? identity());
+        let observed = false;
+        attempted = id;
+        const result = await transport.purchase({ id, route: entry.route, body }, options.signal, async (response) => {
+          observed = true;
+          await options.onResponse?.(response, model);
+        });
+        paid = result;
+        if (!observed)
+          await options.onResponse?.({
+            status: 200,
+            headers: {
+              "content-type": "application/json",
+              "cache-control": "no-store"
+            }
+          }, model);
+        const value = decode(entry, result.body);
+        message.usage = value.usage;
+        message.responseId = value.responseId;
+        options.signal?.throwIfAborted();
+        events.push({ type: "start", partial: message });
+        for (const block of value.content) {
+          const contentIndex = message.content.length;
+          if (block.type === "text") {
+            message.content.push({ ...block, text: "" });
+            events.push({ type: "text_start", contentIndex, partial: message });
+            message.content[contentIndex].text = block.text;
+            events.push({
+              type: "text_delta",
+              contentIndex,
+              delta: block.text,
+              partial: message
+            });
+            events.push({
+              type: "text_end",
+              contentIndex,
+              content: block.text,
+              partial: message
+            });
+          } else if (block.type === "thinking") {
+            message.content.push({
+              ...block,
+              thinking: block.redacted ? block.thinking : ""
+            });
+            events.push({
+              type: "thinking_start",
+              contentIndex,
+              partial: message
+            });
+            if (!block.redacted) {
+              message.content[contentIndex].thinking = block.thinking;
+              events.push({
+                type: "thinking_delta",
+                contentIndex,
+                delta: block.thinking,
+                partial: message
+              });
+            }
+            events.push({
+              type: "thinking_end",
+              contentIndex,
+              content: block.thinking,
+              partial: message
+            });
+          } else {
+            message.content.push({ ...block, arguments: {} });
+            events.push({
+              type: "toolcall_start",
+              contentIndex,
+              partial: message
+            });
+            message.content[contentIndex].arguments = block.arguments;
+            events.push({
+              type: "toolcall_delta",
+              contentIndex,
+              delta: JSON.stringify(block.arguments),
+              partial: message
+            });
+            events.push({
+              type: "toolcall_end",
+              contentIndex,
+              toolCall: block,
+              partial: message
+            });
+          }
+        }
+        message.stopReason = value.stopReason;
+        try {
+          onPaid?.(result);
+        } catch {
+        }
+        events.push({ type: "done", reason: value.stopReason, message });
+      } catch (error) {
+        const aborted = options.signal?.aborted === true;
+        message.stopReason = aborted ? "aborted" : "error";
+        message.errorMessage = aborted ? "Xgate operation stopped. Inspect /xgate status; payment may require reconciliation." : error instanceof XgateError ? error.message : "Xgate operation stopped. Inspect /xgate status before requesting another purchase.";
+        if (attempted !== void 0) {
+          const payment = paid?.payment ?? (error instanceof XgatePurchaseError ? error.payment : void 0);
+          const failure = {
+            invocationId: attempted,
+            code: error instanceof XgateError ? error.code : "purchase_failed",
+            pending: paid === void 0 && !(error instanceof XgatePurchaseError && !error.pending),
+            ...payment ? { payment } : {}
+          };
+          message.errorMessage += ` Billing invocation: ${attempted}.`;
+          try {
+            onPurchaseFailed?.(failure);
+          } catch {
+          }
+        }
+        events.push({
+          type: "error",
+          reason: message.stopReason,
+          error: message
+        });
+      } finally {
+        events.end();
+      }
+    })();
+    return events;
+  };
+  return {
+    id: "xgate",
+    name: "xgate",
+    auth: {
+      apiKey: {
+        name: "Policy constrained xgate wallet",
+        resolve: async () => ({ auth: {}, source: "xgate wallet broker" })
+      }
+    },
+    getModels: () => entries.map((e) => e.model),
+    refreshModels: async (context) => {
+      if (!context.allowNetwork)
+        return;
+      const updated = catalogEntries(await transport.models(context.signal));
+      await context.publish({
+        update: () => {
+          entries = updated;
+        }
+      });
+    },
+    stream: (model, context, options) => stream(model, context, options),
+    streamSimple: stream
+  };
+}
+
+// ../../node_modules/.pnpm/@lucid-agents+pi-xgate@0.1.6_@earendil-works+pi-ai@0.85.1_@earendil-works+pi-coding-agent@0.8_344x6vs3jrzh5eh3xewwgv3ik4/node_modules/@lucid-agents/pi-xgate/dist/extension.js
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/@lucid-agents+xgate-client@0.1.6_@solana+sysvars@5.5.1_typescript@5.7.3_zod@3.25.76/node_modules/@lucid-agents/xgate-client/dist/broker.js
+init_cjs_shims();
+var import_node_http = require("http");
+var import_node_crypto3 = require("crypto");
+
+// ../../node_modules/.pnpm/@lucid-agents+xgate-client@0.1.6_@solana+sysvars@5.5.1_typescript@5.7.3_zod@3.25.76/node_modules/@lucid-agents/xgate-client/dist/http.js
+init_cjs_shims();
+var MAX_BODY = 16 * 1024 * 1024;
+async function bytes(response, limit = MAX_BODY) {
+  requireValue(response.body, "missing_body");
+  const reader = response.body.getReader();
+  const chunks = [];
+  let length = 0;
+  try {
+    for (; ; ) {
+      const part = await reader.read();
+      if (part.done)
+        break;
+      length += part.value.byteLength;
+      requireValue(length <= limit, "body_bound");
+      chunks.push(part.value);
+    }
+  } catch {
+    await reader.cancel().catch(() => {
+    });
+    throw new XgateError("body_unavailable");
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, length);
+}
+async function json(response, limit = MAX_BODY) {
+  try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(await bytes(response, limit)));
+  } catch {
+    throw new XgateError("invalid_response");
+  }
+}
+function signalWithDeadline(signal, ms = 13e4) {
+  return signal ? AbortSignal.any([signal, AbortSignal.timeout(ms)]) : AbortSignal.timeout(ms);
+}
+async function http(fetcher, url, options = {}) {
+  try {
+    return await fetcher(url, {
+      ...options,
+      redirect: "error",
+      cache: "no-store",
+      credentials: "omit",
+      referrerPolicy: "no-referrer"
+    });
+  } catch {
+    throw new XgateError("transport_unresolved");
+  }
+}
+
+// ../../node_modules/.pnpm/@lucid-agents+xgate-client@0.1.6_@solana+sysvars@5.5.1_typescript@5.7.3_zod@3.25.76/node_modules/@lucid-agents/xgate-client/dist/broker.js
+var BrokerClient = class {
+  token;
+  fetcher;
+  url;
+  constructor(url, token, fetcher = fetch) {
+    this.token = token;
+    this.fetcher = fetcher;
+    this.url = origin(url, true);
+    requireValue(/^[a-f0-9]{64}$/.test(token), "invalid_broker_token");
+  }
+  async call(path4, body, signal, onResponse) {
+    const r = await http(this.fetcher, this.url + path4, {
+      method: body === void 0 ? "GET" : "POST",
+      headers: {
+        authorization: "Bearer " + this.token,
+        ...body === void 0 ? {} : { "content-type": "application/json" }
+      },
+      ...body === void 0 ? {} : { body: JSON.stringify(body) },
+      signal: signalWithDeadline(signal, 19e4)
+    });
+    if (onResponse) {
+      try {
+        await onResponse({
+          status: r.status,
+          headers: {
+            "content-type": r.headers.get("content-type") ?? "application/json",
+            "cache-control": "no-store"
+          }
+        });
+      } catch (error) {
+        await r.body?.cancel().catch(() => {
+        });
+        throw error;
+      }
+    }
+    const v = await json(r);
+    if (!r.ok)
+      throw new XgateError(record(v) && typeof v.code === "string" && /^[a-z_]{1,64}$/.test(v.code) ? v.code : "broker_request_failed");
+    return v;
+  }
+  async models(signal) {
+    const v = await this.call("/models", void 0, signal);
+    requireValue(record(v) && Array.isArray(v.data), "invalid_catalog");
+    return v.data;
+  }
+  async purchase(input, signal, onResponse) {
+    const v = await this.call("/purchase", input, signal, onResponse);
+    requireValue(record(v) && record(v.body) && record(v.settlement) && typeof v.purchase === "string", "invalid_broker_result");
+    return v;
+  }
+  async status(signal) {
+    return this.call("/status", void 0, signal);
+  }
+  async receipts(signal) {
+    return this.call("/receipts", void 0, signal);
+  }
+  async reconcile(id, signal) {
+    return this.call("/reconcile", { id }, signal);
+  }
+};
+
+// ../../node_modules/.pnpm/@lucid-agents+pi-xgate@0.1.6_@earendil-works+pi-ai@0.85.1_@earendil-works+pi-coding-agent@0.8_344x6vs3jrzh5eh3xewwgv3ik4/node_modules/@lucid-agents/pi-xgate/dist/extension.js
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_os = require("os");
+function privateText(path4, max = 8192) {
+  if (!(0, import_node_path.isAbsolute)(path4))
+    throw new XgateError("absolute_config_path_required");
+  const s = (0, import_node_fs.lstatSync)(path4);
+  if (!s.isFile() || s.isSymbolicLink() || (s.mode & 63) !== 0 || s.size > max)
+    throw new XgateError("private_config_required");
+  return (0, import_node_fs.readFileSync)(path4, "utf8").trim();
+}
+function standalone(configPath) {
+  const cfg = JSON.parse(privateText(configPath));
+  if (typeof cfg.url !== "string" || typeof cfg.tokenFile !== "string")
+    throw new XgateError("invalid_config");
+  return new BrokerClient(cfg.url, privateText(cfg.tokenFile, 128));
+}
+function paymentStatus(p) {
+  const left = p.channel ? `; channel ${p.channel.refundableAtomic} refundable` : "";
+  return `xgate paid ${p.chargedAtomic ?? "?"}/${p.authorizedAtomic} ${p.asset} on ${p.network} (${p.scheme})${left}`;
+}
+function createXgateExtension(options = {}) {
+  return (pi2) => register(pi2, options);
+}
+var extension_default = createXgateExtension();
+async function register(pi2, options) {
+  const injected = options.transport;
+  const configPath = process.env.XGATE_CONFIG ?? (0, import_node_path.join)((0, import_node_os.homedir)(), ".pi", "agent", "xgate.json");
+  let broker;
+  let context;
+  const load = async () => {
+    const next = injected === void 0 ? standalone(configPath) : typeof injected === "function" ? await injected() : injected;
+    const provider = await createXgateProvider(next, {
+      sessionId: () => context?.sessionManager.getSessionId() ?? "standalone",
+      onPaid: (r) => context?.ui.setStatus("xgate", r.payment ? paymentStatus(r.payment) : `xgate paid ${(Number(r.settlement.chargedAtomic) / 1e6).toFixed(6)}`),
+      onPurchaseFailed: (f) => context?.ui.setStatus("xgate", `xgate ${f.pending ? "unresolved" : "failed"}: ${f.invocationId}`)
+    });
+    pi2.registerProvider(provider);
+    broker = next;
+  };
+  try {
+    await load();
+  } catch {
+  }
+  pi2.on("session_start", async (_event, ctx) => {
+    context = ctx;
+    ctx.ui.setStatus("xgate", broker ? "xgate wallet ready" : "xgate: /xgate refresh or /xgate setup");
+  });
+  pi2.on("cache_warming_decision", async (event, ctx) => ctx.model?.provider === "xgate" ? { action: "stop" } : void 0);
+  pi2.registerCommand("xgate", {
+    description: "Set up the wallet broker; show budget or reconcile an existing purchase.",
+    handler: async (args, ctx) => {
+      context = ctx;
+      const [command, id] = args.trim().split(/\s+/);
+      try {
+        if (command === "setup") {
+          if (injected !== void 0)
+            throw new XgateError("transport_managed_by_host");
+          if (!ctx.hasUI)
+            throw new XgateError("configure_XGATE_CONFIG_for_headless_mode");
+          const url = await ctx.ui.input("xgate wallet service", "http://127.0.0.1:4021");
+          if (!url)
+            return;
+          const tokenFile = await ctx.ui.input("Absolute path to the broker token file", "/private/path/broker-token");
+          if (!tokenFile)
+            return;
+          const next = new BrokerClient(url, privateText(tokenFile, 128));
+          await next.status();
+          (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(configPath), { recursive: true, mode: 448 });
+          (0, import_node_fs.writeFileSync)(configPath, JSON.stringify({ url, tokenFile }) + "\n", {
+            mode: 384,
+            flag: "wx"
+          });
+          await load();
+          ctx.ui.notify("xgate configured. Select a qualified model with /model.", "info");
+          return;
+        }
+        if (command === "refresh") {
+          await load();
+          ctx.ui.notify("xgate model list refreshed.", "info");
+          return;
+        }
+        if (!broker)
+          throw new XgateError("wallet_not_configured");
+        if (command === "reconcile") {
+          if (!id)
+            throw new XgateError("purchase_id_required");
+          if (!broker.reconcile)
+            throw new XgateError("unsupported_by_transport");
+          const result = await broker.reconcile(id);
+          ctx.ui.notify(JSON.stringify(result), "info");
+          return;
+        }
+        if (command === "receipts") {
+          if (!broker.receipts)
+            throw new XgateError("unsupported_by_transport");
+          ctx.ui.notify(JSON.stringify(await broker.receipts(), null, 2), "info");
+          return;
+        }
+        if (command === "status" || command === "budget" || !command) {
+          if (!broker.status)
+            throw new XgateError("unsupported_by_transport");
+          const status = await broker.status();
+          ctx.ui.notify(JSON.stringify(status, null, 2), "info");
+          return;
+        }
+        ctx.ui.notify("Use /xgate setup, refresh, status, budget, receipts or reconcile <invocation ID>. Budgets are configured at the wallet service.", "info");
+      } catch (error) {
+        ctx.ui.notify(error instanceof XgateError ? error.message : "xgate setup failed; check the private configuration and wallet service.", "error");
+      }
+    }
+  });
+}
+
+// ../../node_modules/.pnpm/@lucid-agents+pi-xgate@0.1.6_@earendil-works+pi-ai@0.85.1_@earendil-works+pi-coding-agent@0.8_344x6vs3jrzh5eh3xewwgv3ik4/node_modules/@lucid-agents/pi-xgate/dist/taskmarket.js
+init_cjs_shims();
+var CATALOG_BYTES = 2 * 1024 * 1024;
+var REQUEST_BYTES = 8 * 1024 * 1024;
+
+// ../../packages/agent-host/dist/index.js
+init_cjs_shims();
+
+// ../../packages/agent-host/dist/context.js
+init_cjs_shims();
+
+// ../../packages/agent-host/dist/custody.js
+init_cjs_shims();
+var import_node_util = require("util");
+
+// ../../packages/agent-host/dist/redact.js
+init_cjs_shims();
+var REDACTED = "[REDACTED]";
+var MIN_SECRET_LENGTH = 8;
+var MIN_PEM_LINE_LENGTH = 16;
+var PEM_WRAP_WIDTHS = [64, 70, 76];
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var toUrlSafe = (b64) => b64.replace(/\+/g, "-").replace(/\//g, "_");
+function base64Forms(bytes2) {
+  const forms = [];
+  const padded = bytes2.toString("base64");
+  forms.push(padded, padded.replace(/=+$/, ""));
+  const skip = [0, 2, 3];
+  for (let offset = 0; offset < 3; offset++) {
+    const encoded = Buffer.concat([Buffer.alloc(offset), bytes2]).toString("base64").replace(/=+$/, "");
+    forms.push(encoded.slice(skip[offset], Math.floor((offset + bytes2.length) * 8 / 6)));
+  }
+  return [...forms, ...forms.map(toUrlSafe)];
+}
+function wrap(text2, width) {
+  const lines2 = [];
+  for (let i = 0; i < text2.length; i += width)
+    lines2.push(text2.slice(i, i + width));
+  return lines2;
+}
+function secretVariants(secret) {
+  const variants = /* @__PURE__ */ new Set();
+  const trimmed = secret.trim();
+  const bases = /* @__PURE__ */ new Set([secret, trimmed]);
+  if (/^0x[0-9a-fA-F]+$/.test(trimmed))
+    bases.add(trimmed.slice(2));
+  for (const base of bases) {
+    const bytes2 = Buffer.from(base, "utf8");
+    const hex = bytes2.toString("hex");
+    for (const form of [
+      base,
+      ...base64Forms(bytes2),
+      encodeURIComponent(base),
+      hex,
+      hex.toUpperCase(),
+      JSON.stringify(base).slice(1, -1)
+    ]) {
+      variants.add(form);
+    }
+  }
+  if (trimmed.includes("-----BEGIN ")) {
+    const bodyLines = trimmed.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("-----"));
+    for (const line of bodyLines) {
+      if (line.length >= MIN_PEM_LINE_LENGTH)
+        variants.add(line);
+    }
+    const body = bodyLines.join("");
+    variants.add(body);
+    for (const width of PEM_WRAP_WIDTHS) {
+      const lines2 = wrap(body, width);
+      variants.add(lines2.join("\n"));
+      variants.add(lines2.join("\r\n"));
+    }
+  }
+  return [...variants].filter((variant) => variant.length >= MIN_SECRET_LENGTH);
+}
+function createRedactor(secrets) {
+  const variants = /* @__PURE__ */ new Set();
+  for (const secret of secrets) {
+    if (secret.trim().length < MIN_SECRET_LENGTH)
+      continue;
+    for (const variant of secretVariants(secret))
+      variants.add(variant);
+  }
+  if (variants.size === 0)
+    return (text2) => text2;
+  const ordered = [...variants].sort((a, b) => b.length - a.length);
+  const pattern = new RegExp(ordered.map(escapeRegExp).join("|"), "gi");
+  return (text2) => text2.replace(pattern, REDACTED);
+}
+
+// ../../packages/agent-host/dist/custody.js
+var CustodyError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CustodyError";
+  }
+};
+var ControllerCustody = class {
+  #wallets = /* @__PURE__ */ new Map();
+  #handles = /* @__PURE__ */ new Map();
+  #secrets = /* @__PURE__ */ new Set();
+  #apiToken;
+  #sandbox;
+  #redactor = (text2) => text2;
+  /** Adds a rail wallet. A rail holds one wallet; replacing it needs an explicit `removeWallet`. */
+  addWallet(wallet) {
+    if (this.#wallets.has(wallet.rail)) {
+      throw new CustodyError(`A wallet is already held for rail ${wallet.rail}`);
+    }
+    for (const secret of wallet.secrets ?? [])
+      this.addSecret(secret);
+    this.#wallets.set(wallet.rail, { ...wallet, secrets: void 0 });
+  }
+  removeWallet(rail) {
+    return this.#wallets.delete(rail);
+  }
+  wallet(rail) {
+    return this.#wallets.get(rail);
+  }
+  rails() {
+    return [...this.#wallets.keys()];
+  }
+  setApiToken(apiToken) {
+    this.addSecret(apiToken);
+    this.#apiToken = apiToken;
+  }
+  apiToken() {
+    if (!this.#apiToken)
+      throw new CustodyError("No apiToken is held");
+    return this.#apiToken;
+  }
+  setSandboxCredentials(credentials) {
+    this.addSecret(credentials.apiKey);
+    this.addSecret(credentials.sshPrivateKey);
+    this.#sandbox = { ...credentials };
+  }
+  sandboxCredentials() {
+    if (!this.#sandbox)
+      throw new CustodyError("No sandbox credentials are held");
+    return { ...this.#sandbox };
+  }
+  /** Stores an opaque controller-side handle, such as the x402 payer or a channel state store. */
+  setHandle(name, handle) {
+    this.#handles.set(name, handle);
+  }
+  handle(name) {
+    return this.#handles.get(name);
+  }
+  /** Registers any other secret value (a provider key, a session token) for redaction. */
+  addSecret(secret) {
+    if (secret.trim().length < MIN_SECRET_LENGTH) {
+      throw new CustodyError(`Secrets must be at least ${MIN_SECRET_LENGTH} characters`);
+    }
+    if (this.#secrets.has(secret))
+      return;
+    this.#secrets.add(secret);
+    this.#redactor = createRedactor(this.#secrets);
+  }
+  /** Scrubs every held secret from a string (a tool result, a log line, an error message). */
+  redact(text2) {
+    return this.#redactor(text2);
+  }
+  /** The current redactor, as a plain function that can be handed to a seam. */
+  redactor() {
+    return this.#redactor;
+  }
+  summary() {
+    return {
+      rails: [...this.#wallets.values()].map(({ rail, address }) => ({ rail, address })),
+      hasApiToken: this.#apiToken !== void 0,
+      hasSandboxCredentials: this.#sandbox !== void 0,
+      handles: [...this.#handles.keys()]
+    };
+  }
+  toJSON() {
+    return this.summary();
+  }
+  [import_node_util.inspect.custom]() {
+    return `ControllerCustody ${JSON.stringify(this.summary())}`;
+  }
+};
+
+// ../../packages/agent-host/dist/env.js
+init_cjs_shims();
+
+// ../../packages/agent-host/dist/home.js
+init_cjs_shims();
+var import_node_os2 = __toESM(require("os"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+
+// ../../packages/agent-host/dist/launch.js
+init_cjs_shims();
+var import_node_fs2 = require("fs");
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+
+// ../../packages/agent-host/dist/lockdown-extension.js
+init_cjs_shims();
+
+// ../../packages/agent-host/dist/tools.js
+init_cjs_shims();
+
+// ../../packages/agent-host/dist/secrets-channel.js
+init_cjs_shims();
+var import_node_net = __toESM(require("net"), 1);
+var MAX_SECRETS_PAYLOAD_BYTES = 1024 * 1024;
+
+// ../../packages/agent-host/dist/launch.js
+var INFERENCE_CHANNEL_FDS_ENV = "TASKMARKET_PI_INFERENCE_FDS";
+var here = import_node_path3.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+
+// ../../packages/agent-host/dist/sdk.js
+init_cjs_shims();
+var import_node_path4 = __toESM(require("path"), 1);
+var import_pi_coding_agent = require("@earendil-works/pi-coding-agent");
+
+// src/lib/agent/inference-channel.ts
+init_cjs_shims();
+var import_net = __toESM(require("net"), 1);
+var MAX_MESSAGE_BYTES = 48 * 1024 * 1024;
+var VIEW_TIMEOUT_MS = 6e4;
+var CODE = /^[a-z0-9_]{1,64}$/;
+function lines(stream, onLine, onOverflow, maxBytes) {
+  let chunks = [];
+  let size = 0;
+  let discarding = false;
+  const head = (rest) => Buffer.concat([...chunks, rest]).subarray(0, 64).toString("utf8");
+  stream.on("data", (chunk) => {
+    let data = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    for (let i = data.indexOf(10); i >= 0; i = data.indexOf(10)) {
+      if (discarding) {
+        discarding = false;
+      } else if (size + i > maxBytes) {
+        onOverflow(head(data.subarray(0, i)));
+      } else {
+        const line = Buffer.concat([...chunks, data.subarray(0, i)]).toString("utf8");
+        if (line.trim()) onLine(line);
+      }
+      chunks = [];
+      size = 0;
+      data = data.subarray(i + 1);
+    }
+    if (data.length === 0 || discarding) return;
+    if (size + data.length > maxBytes) {
+      onOverflow(head(data));
+      chunks = [];
+      size = 0;
+      discarding = true;
+      return;
+    }
+    chunks.push(data);
+    size += data.length;
+  });
+}
+function wireToError(wire, invocationId2) {
+  const e = wire ?? {};
+  const code = typeof e.code === "string" && CODE.test(e.code) ? e.code : "controller_failed";
+  if (invocationId2 !== void 0) {
+    return new XgatePurchaseError(
+      code,
+      invocationId2,
+      e.pending !== false,
+      e.payment && typeof e.payment === "object" ? e.payment : void 0
+    );
+  }
+  return new XgateError(code);
+}
+var ChannelXgateTransport = class _ChannelXgateTransport {
+  /** `replies` carries the controller's answers; `requests` carries Pi's requests to it. */
+  constructor(replies, requests, options = {}) {
+    this.requests = requests;
+    this.maxBytes = options.maxMessageBytes ?? MAX_MESSAGE_BYTES;
+    lines(
+      replies,
+      (line) => this.onLine(line),
+      () => this.fail("the controller sent an oversized message"),
+      this.maxBytes
+    );
+    for (const stream of [replies, requests]) {
+      stream.on("error", (error) => this.fail(`the inference channel failed: ${error.message}`));
+      stream.on("close", () => this.fail("the controller closed the inference channel"));
+    }
+    replies.on("end", () => this.fail("the controller closed the inference channel"));
+  }
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  closedReason;
+  closeListeners = [];
+  maxBytes;
+  /** Opens the inherited descriptors the launcher named. */
+  static fromFds(fds) {
+    const requests = new import_net.default.Socket({ fd: fds.request, readable: false, writable: true });
+    const replies = new import_net.default.Socket({ fd: fds.reply, readable: true, writable: false });
+    requests.unref();
+    replies.unref();
+    return new _ChannelXgateTransport(replies, requests);
+  }
+  fail(reason) {
+    if (this.closedReason) return;
+    this.closedReason = reason;
+    for (const { reject } of this.pending.values()) reject(new Error(reason));
+    this.pending.clear();
+    for (const listener of this.closeListeners.splice(0)) listener(reason);
+  }
+  /** Calls `listener` once when the controller is gone (now, if it already is). */
+  onClose(listener) {
+    if (this.closedReason) listener(this.closedReason);
+    else this.closeListeners.push(listener);
+  }
+  onLine(line) {
+    let reply;
+    try {
+      reply = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const waiter = this.pending.get(reply?.id);
+    if (!waiter) return;
+    this.pending.delete(reply.id);
+    waiter.resolve(reply);
+  }
+  send(body, options) {
+    if (this.closedReason) return void 0;
+    const id = this.nextId++;
+    const line = `${JSON.stringify({ id, ...body })}
+`;
+    if (Buffer.byteLength(line) > this.maxBytes) return "too_large";
+    const reply = new Promise((resolve, reject) => {
+      const timer = options.timeoutMs === void 0 ? void 0 : setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error("the controller did not answer in time"));
+      }, options.timeoutMs);
+      const onAbort = () => {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        options.onAbort?.(id);
+        reject(new Error("aborted"));
+      };
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+      const settle = () => {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", onAbort);
+      };
+      this.pending.set(id, {
+        resolve: (value) => {
+          settle();
+          resolve(value);
+        },
+        reject: (error) => {
+          settle();
+          reject(error);
+        }
+      });
+    });
+    this.requests.write(line);
+    return { id, reply };
+  }
+  async view(body, signal) {
+    const sent = this.send(body, { timeoutMs: VIEW_TIMEOUT_MS, signal });
+    if (sent === "too_large") throw new XgateError("message_too_large");
+    if (!sent) throw new XgateError("controller_unavailable");
+    let reply;
+    try {
+      reply = await sent.reply;
+    } catch {
+      throw new XgateError(signal?.aborted ? "aborted" : "controller_unavailable");
+    }
+    if (reply.error) throw wireToError(reply.error);
+    return reply;
+  }
+  async models(signal) {
+    signal?.throwIfAborted();
+    let reply;
+    try {
+      reply = await this.view({ op: "models" }, signal);
+    } catch (error) {
+      throw error instanceof XgateError && error.code !== "controller_unavailable" ? error : new XgateError("catalog_unavailable");
+    }
+    if (!Array.isArray(reply.rows)) throw new XgateError("invalid_catalog");
+    return reply.rows;
+  }
+  async purchase(invocation, signal) {
+    const id = invocation.id;
+    if (signal?.aborted) throw new XgatePurchaseError("aborted", id, false);
+    const sent = this.send(
+      { op: "purchase", invocation: { id, route: invocation.route, body: invocation.body } },
+      {
+        signal,
+        // Tell the controller to stop; its payer records the real outcome in the journal.
+        onAbort: (target) => {
+          if (!this.closedReason)
+            this.requests.write(`${JSON.stringify({ id: this.nextId++, op: "abort", target })}
+`);
+        }
+      }
+    );
+    if (sent === "too_large") throw new XgatePurchaseError("message_too_large", id, false);
+    if (!sent) throw new XgatePurchaseError("controller_unavailable", id, false);
+    let reply;
+    try {
+      reply = await sent.reply;
+    } catch {
+      throw new XgatePurchaseError(
+        signal?.aborted ? "aborted" : "controller_unavailable",
+        id,
+        true
+      );
+    }
+    if (reply.error) throw wireToError(reply.error, id);
+    const result = reply.result;
+    if (!result || typeof result !== "object" || !("body" in result) || !result.settlement) {
+      throw new XgatePurchaseError("invalid_result", id, true);
+    }
+    return result;
+  }
+  async status(signal) {
+    return (await this.view({ op: "status" }, signal)).value;
+  }
+  async reconcile(invocationId2, signal) {
+    return (await this.view({ op: "reconcile", invocationId: invocationId2 }, signal)).value;
+  }
+};
+function unavailableTransport() {
+  return {
+    models: () => Promise.reject(new XgateError("catalog_unavailable")),
+    purchase: (invocation) => Promise.reject(new XgatePurchaseError("controller_unavailable", invocation.id, false))
+  };
+}
+
+// src/pi-extensions/xgate.ts
+var log = (message) => console.error(`[taskmarket] ${message}`);
+function openTransport() {
+  const [request, reply] = (process.env[INFERENCE_CHANNEL_FDS_ENV] ?? "").split(",").map(Number);
+  if (!Number.isInteger(request) || !Number.isInteger(reply) || request <= 2 || reply <= 2) {
+    log("Pi was launched without an inference channel; xgate models are unavailable");
+    return unavailableTransport();
+  }
+  try {
+    return ChannelXgateTransport.fromFds({ request, reply });
+  } catch (error) {
+    log(`The inference channel cannot be opened: ${error.message}`);
+    return unavailableTransport();
+  }
+}
+async function taskmarketXgate(pi2) {
+  const transport = openTransport();
+  await createXgateExtension({ transport })(pi2);
+  let context;
+  let controllerGone = false;
+  pi2.on("session_start", async (_event, ctx) => {
+    context = ctx;
+    if (controllerGone) ctx.shutdown();
+  });
+  if (transport instanceof ChannelXgateTransport) {
+    transport.onClose((reason) => {
+      log(`The taskmarket controller is gone (${reason}); ending the session`);
+      controllerGone = true;
+      context?.shutdown();
+    });
+  }
+  pi2.on("model_select", async (event, ctx) => {
+    if (event.model.provider === "xgate") return;
+    const fallback = event.previousModel?.provider === "xgate" ? event.previousModel : ctx.modelRegistry.getAvailable().find((model) => model.provider === "xgate");
+    if (fallback) await pi2.setModel(fallback);
+    ctx.ui.notify("taskmarket agent offers only the xgate models your policy approves", "warning");
+  });
+}
+module.exports = module.exports.default;