@xanots/sdk 0.0.1

package/dist/chunk-YDZYMZBE.js

@@ -0,0 +1,670 @@
+import {
+  encodeEval,
+  encodeSearch,
+  encodeSort,
+  qualifyAggregateEvals,
+  realtimeChannelGuid,
+  realtimeServerRefName,
+  resolveRealtimeServerRef
+} from "./chunk-FJ6ZS5KB.js";
+import {
+  assertCanonical,
+  assertOneOf,
+  assertStoredName,
+  buildMiddlewareBlock,
+  clear,
+  emitDiagnostic,
+  emptyMiddleware,
+  encodeContainerHistory,
+  encodeHistory,
+  encodeInput,
+  encodeResponse,
+  encodeTags,
+  encodeTests,
+  registerKind,
+  resolveAuthRef,
+  resolveMockKeys,
+  warnLiveDatasource
+} from "./chunk-EMCAWMHC.js";
+import {
+  encodeStatement
+} from "./chunk-LH6Z6KFV.js";
+import {
+  deriveGuid,
+  getLockedCanonical,
+  lockKey,
+  realtimeMessageSeedName,
+  resolveRef
+} from "./chunk-4HT3BNZ7.js";
+
+// src/kinds/canonical.ts
+function resolveCanonicalToken(label, payloadKey, accessor, def, override) {
+  if (override) return override;
+  if (typeof def.canonical === "string" && def.canonical !== "") return def.canonical;
+  const locked = getLockedCanonical(lockKey(payloadKey, def.name));
+  if (locked) return locked;
+  throw new Error(
+    `${label} "${def.name}": cannot resolve the \`canonical\` URL token. Set an explicit \`canonical\` in code, or run \`xanots export <entry> --lock\` once (it mints a unique canonical and freezes it in xano.lock) and seed that lock before importing defs \u2014 the CLI does this automatically. As a last resort pass one directly (e.g. \`${accessor}({ canonical: "..." })\`). (Minting here is unsafe \u2014 canonicals must be unique per instance across all workspaces, so they are only generated at locked export.)`
+  );
+}
+
+// src/kinds/toolset.ts
+function encodeTool(def) {
+  if (!def.name) throw new Error("tool: `name` is required.");
+  assertStoredName(`tool "${def.name}"`, def.name, "route");
+  return {
+    name: def.name,
+    description: def.description ?? "",
+    instructions: def.instructions ?? "",
+    docs: def.docs ?? "",
+    enabled: def.enabled ?? true,
+    output: [],
+    middleware: buildMiddlewareBlock(def.middleware),
+    tag: encodeTags(def.tags),
+    history: encodeHistory("tool", def.history),
+    toolset: { id: def.toolsetId ?? 0 },
+    input: Object.entries(def.input ?? {}).map(([name, d]) => encodeInput(name, d)),
+    result: encodeResponse(def.response),
+    run: (def.stack ?? []).map(encodeStatement),
+    test: []
+  };
+}
+var toolKind = {
+  name: "tool",
+  payloadKey: "tool",
+  encode: encodeTool
+};
+registerKind(toolKind);
+function tool(def) {
+  return def;
+}
+function normalizeToolEntry(entry, index) {
+  if (typeof entry === "string") return { tool: entry };
+  if (entry === null || typeof entry !== "object") {
+    throw new Error(
+      `toolset tool ref [${index}]: expected a \`tool()\` handle, a tool name, or a { tool, enabled?, auth? } wrapper (got ${entry === null ? "null" : typeof entry}).`
+    );
+  }
+  const ref = entry;
+  if (ref.tool !== void 0 || ref.id !== void 0) return ref;
+  if (typeof ref.name === "string" && ref.name !== "") {
+    return { tool: ref };
+  }
+  throw new Error(
+    `toolset tool ref [${index}]: names no tool. Pass the \`tool()\` handle (\`tools: [saveNote]\`), its name, or a wrapper (\`{ tool: saveNote, auth: users }\`). An entry with neither \`tool\` nor \`id\` encodes to \`id: 0\` \u2014 a reference to nothing, which deploys as a toolset whose tool is silently missing.`
+  );
+}
+function encodeToolRefs(tools) {
+  return (tools ?? []).map((entry, index) => {
+    const t = normalizeToolEntry(entry, index);
+    if (t.tool !== void 0 && t.id !== void 0) {
+      throw new Error("toolset tool ref: set either `tool` (handle/name) or `id` (raw), not both.");
+    }
+    const id = t.tool !== void 0 ? resolveRef("tool", t.tool) : t.id ?? 0;
+    if (id === 0 || id === "" || id === "0") {
+      emitDiagnostic({
+        severity: "warning",
+        code: "toolset.tool-ref-zero",
+        message: `toolset tool ref [${index}] is \`id: 0\`, which references no tool \u2014 engine ids start at 1. It deploys as a tool entry pointing at nothing, so the toolset simply never calls it, with no error anywhere. Pass the \`tool()\` handle (\`tools: [saveNote]\`) so the reference resolves to its guid.`
+      });
+    }
+    const label = typeof t.tool === "string" ? t.tool : t.tool?.name ?? String(t.id ?? "?");
+    return { id, enabled: t.enabled ?? true, auth: resolveAuthRef("toolset tool", label, t.auth) };
+  });
+}
+function resolveToolsetCanonical(def, override) {
+  return resolveCanonicalToken("toolset", "toolset", "getPath", def, override);
+}
+function encodeToolsetBase(def, label = "toolset") {
+  assertCanonical(`${label} "${def.name}"`, def.canonical);
+  return {
+    name: def.name,
+    description: def.description ?? "",
+    instructions: def.instructions ?? "",
+    docs: def.docs ?? "",
+    enabled: def.enabled ?? true,
+    canonical: def.canonical ?? "",
+    spec: def.spec ?? "",
+    middleware: emptyMiddleware(),
+    history: encodeContainerHistory("tool", def.history),
+    tag: encodeTags(def.tags),
+    tool: encodeToolRefs(def.tools)
+  };
+}
+
+// src/kinds/agent.ts
+function buildProviderConfig(llm) {
+  let config;
+  switch (llm.type) {
+    case "anthropic":
+      config = {
+        apiKey: llm.apiKey ?? "",
+        model: llm.model ?? "",
+        temperature: llm.temperature ?? 1,
+        sendReasoning: llm.sendReasoning ?? true,
+        thinking: llm.thinkingTokens !== void 0 ? { type: "enabled", budgetTokens: llm.thinkingTokens } : { type: "disabled", budgetTokens: "" },
+        baseURL: llm.baseURL ?? "",
+        headers: llm.headers ?? ""
+      };
+      break;
+    case "openai":
+      config = {
+        apiKey: llm.apiKey ?? "",
+        model: llm.model ?? "",
+        temperature: llm.temperature ?? 1,
+        reasoningEffort: llm.reasoningEffort ?? "medium",
+        baseURL: llm.baseURL ?? "",
+        headers: llm.headers ?? "",
+        organization: llm.organization ?? "",
+        project: llm.project ?? "",
+        compatibility: llm.compatibility ?? "strict"
+      };
+      break;
+    case "google-genai":
+      config = {
+        apiKey: llm.apiKey ?? "",
+        model: llm.model ?? "",
+        temperature: llm.temperature ?? 1,
+        useSearchGrounding: llm.searchGrounding ?? false,
+        thinkingConfig: {
+          includeThoughts: llm.includeThoughts ?? false,
+          thinkingBudget: llm.thinkingBudget ?? 0
+        },
+        baseURL: llm.baseURL ?? "",
+        headers: llm.headers ?? "",
+        safetySettings: llm.safetySettings ?? "",
+        dynamicRetrievalConfig: llm.dynamicRetrieval ?? ""
+      };
+      break;
+    case "xano-free":
+      config = {
+        temperature: llm.temperature ?? 1,
+        useSearchGrounding: llm.searchGrounding ?? false,
+        thinkingConfig: {
+          includeThoughts: llm.includeThoughts ?? false,
+          thinkingBudget: llm.thinkingBudget ?? 0
+        },
+        baseURL: llm.baseURL ?? "",
+        headers: llm.headers ?? "",
+        safetySettings: llm.safetySettings ?? "",
+        dynamicRetrievalConfig: llm.dynamicRetrieval ?? ""
+      };
+      break;
+  }
+  return llm.extraConfig ? { ...config, ...llm.extraConfig } : config;
+}
+function buildAgentSettings(def) {
+  const llm = def.llm;
+  if (llm.prompt !== void 0 && llm.messages !== void 0) {
+    throw new Error(
+      "agent llm: `prompt` and `messages` are two spellings of ONE run prompt and cannot both be set \u2014 the engine stores a single `prompt_type`, so one of them would be dropped. Keep `prompt` for a plain string, or `messages` for a messages template."
+    );
+  }
+  const promptType = llm.messages !== void 0 ? "messages" : "prompt";
+  return {
+    type: llm.type,
+    system_prompt: llm.systemPrompt ?? "",
+    max_steps: llm.maxSteps ?? 5,
+    prompt_type: promptType,
+    prompt: promptType === "prompt" ? llm.prompt ?? "" : "",
+    prompt_messages: promptType === "messages" ? llm.messages ?? "" : "",
+    structuredOutputs: def.output ? def.output.enabled ?? true : false,
+    structuredOutputsSchema: def.output ? Object.entries(def.output.schema).map(([name, d]) => encodeInput(name, d)) : [],
+    configs: { [llm.type]: buildProviderConfig(llm) }
+  };
+}
+function encodeAgent(def) {
+  if (!def.name) throw new Error("agent: `name` is required.");
+  if (!def.llm) throw new Error("agent: `llm` is required.");
+  return {
+    ...encodeToolsetBase(def, "agent"),
+    type: "agent",
+    agent_settings: buildAgentSettings(def)
+  };
+}
+var agentKind = {
+  name: "agent",
+  payloadKey: "toolset",
+  encode: encodeAgent
+};
+registerKind(agentKind);
+function agent(def) {
+  const getCanonical = (opts) => resolveToolsetCanonical(def, opts?.canonical);
+  return { ...def, getCanonical };
+}
+
+// src/kinds/mcp-server.ts
+function encodeMcpServer(def) {
+  if (!def.name) throw new Error("mcp server: `name` is required.");
+  const base = { ...encodeToolsetBase(def, "mcpServer"), type: "mcp" };
+  return def.llm === void 0 ? base : { ...base, agent_settings: buildAgentSettings({ llm: def.llm, output: def.output }) };
+}
+var mcpServerKind = {
+  name: "mcp_server",
+  payloadKey: "toolset",
+  encode: encodeMcpServer
+};
+registerKind(mcpServerKind);
+function assertNotResolvedEndpointBase(base) {
+  const shape = /(\/x2\/mcp\/[^/]+\/)[^/]+(\/stream)$/i;
+  if (!shape.test(base)) return;
+  const redacted = base.replace(shape, "$1<token>$2");
+  throw new Error(
+    `mcp server: \`getUrl\` was given a base URL that already carries an MCP endpoint path (${redacted}). Pass the INSTANCE base URL, not the result of a previous getUrl() \u2014 resolving twice appends a second "/x2/mcp/<canonical>/<token>/stream".`
+  );
+}
+function mcpServer(def) {
+  const getPath = (opts) => `/x2/mcp/${resolveToolsetCanonical(def, opts?.canonical)}/${opts?.token || "mcp"}/stream`;
+  const getUrl = (baseUrl, opts) => {
+    const base = (baseUrl ?? "").trim().replace(/\/+$/, "");
+    if (!base) throw new Error('mcp server: `getUrl` needs a base URL (e.g. "https://x.dev.xano.io").');
+    assertNotResolvedEndpointBase(base);
+    return `${base}${getPath(opts)}`;
+  };
+  return { ...def, getPath, getUrl };
+}
+
+// src/kinds/api-group.ts
+var CORS_MODES = ["default", "custom", "disabled"];
+function encodeCors(context, cors) {
+  assertOneOf(
+    context,
+    "cors.mode",
+    cors?.mode,
+    CORS_MODES,
+    'The engine does not reject an unrecognized mode and does not blank the field \u2014 it DROPS THE ENTIRE API GROUP on import. The deploy reports success, the group is missing, and every query in it 404s "Unable to locate request."'
+  );
+  return {
+    mode: cors?.mode ?? "default",
+    allowOrigins: cors?.allowOrigins ?? [],
+    allowHeaders: cors?.allowHeaders ?? [],
+    allowCredentials: cors?.allowCredentials ?? false,
+    maxAge: cors?.maxAge ?? 0,
+    allowMethods: {
+      delete: cors?.allowMethods?.delete ?? false,
+      get: cors?.allowMethods?.get ?? false,
+      head: cors?.allowMethods?.head ?? false,
+      patch: cors?.allowMethods?.patch ?? false,
+      post: cors?.allowMethods?.post ?? false,
+      put: cors?.allowMethods?.put ?? false
+    }
+  };
+}
+function encodeApiGroup(def) {
+  if (!def.name) throw new Error("apiGroup: `name` is required.");
+  assertCanonical(`apiGroup "${def.name}"`, def.canonical);
+  return {
+    name: def.name,
+    description: def.description ?? "",
+    canonical: def.canonical ?? "",
+    swagger: def.swagger ?? false,
+    api_group_enabled: def.apiGroupEnabled ?? true,
+    docs: def.docs ?? "",
+    documentation: def.documentation ?? { require_token: false, token: "" },
+    middleware: buildMiddlewareBlock(def.middleware),
+    history: encodeContainerHistory("query", def.history),
+    tag: encodeTags(def.tags),
+    cors: encodeCors(`apiGroup "${def.name}"`, def.cors)
+  };
+}
+var apiGroupKind = {
+  name: "api_group",
+  payloadKey: "app",
+  encode: encodeApiGroup
+};
+registerKind(apiGroupKind);
+function apiGroup(def) {
+  return def;
+}
+
+// src/kinds/realtime-server.ts
+function resolveRealtimeServerCanonical(def, override) {
+  return resolveCanonicalToken("realtime server", "realtime_server", "getCanonical", def, override);
+}
+function encodeRealtimeServer(def) {
+  if (!def.name) throw new Error("realtimeServer: `name` is required.");
+  assertCanonical(`realtimeServer "${def.name}"`, def.canonical);
+  return {
+    name: def.name,
+    description: def.description ?? "",
+    canonical: def.canonical ?? "",
+    enabled: def.enabled ?? false,
+    history: encodeContainerHistory("message", def.history),
+    tag: encodeTags(def.tags)
+  };
+}
+var realtimeServerKind = {
+  name: "realtime_server",
+  payloadKey: "realtime_server",
+  encode: encodeRealtimeServer
+};
+registerKind(realtimeServerKind);
+function assertTenant(tenant) {
+  if (!/^[A-Za-z0-9-]+$/.test(tenant)) {
+    throw new Error(
+      `realtime server: invalid \`tenant\` ${JSON.stringify(tenant)} \u2014 a tenant name is alphanumeric with dashes (e.g. "xxxx-xxxx-xxxx"). It rides as a "<tenant>:<canonical>" prefix, so ":" and "/" cannot appear in it.`
+    );
+  }
+  return tenant;
+}
+function assertNotResolvedSocketBase(fn, socketBase, given) {
+  if (!/\/ws\/[^/]+$/i.test(socketBase)) return;
+  throw new Error(
+    `realtime server: \`${fn}\` was given a base URL that already carries a socket path (${given}). Pass the http(s) INSTANCE base URL, not the result of a previous getUrl()/socketUrl() \u2014 resolving twice appends a second "/ws/<canonical>" and drops the tenant.`
+  );
+}
+function liftTenantFromBase(socketBase, explicit) {
+  const m = /^(wss?:\/\/[^/]+)\/tenant\/([^/]+)(\/.*)?$/i.exec(socketBase);
+  if (!m) return { base: socketBase, tenant: explicit };
+  const origin = m[1];
+  const fromBase = m[2];
+  const rest = m[3] ?? "";
+  if (explicit !== void 0 && explicit !== fromBase) {
+    throw new Error(
+      `realtime server: \`getUrl\` was given tenant ${JSON.stringify(explicit)} but the base URL names ${JSON.stringify(fromBase)} (".../tenant/${fromBase}"). Refusing to guess which one you meant \u2014 pass the matching tenant, or a base URL without the "/tenant/<name>" prefix.`
+    );
+  }
+  return { base: `${origin}${rest}`, tenant: assertTenant(fromBase) };
+}
+function realtimeServer(def) {
+  const getCanonical = (opts) => resolveRealtimeServerCanonical(def, opts?.canonical);
+  const getPath = (opts) => {
+    const canonical = getCanonical(opts);
+    const prefix = opts?.tenant ? `${assertTenant(opts.tenant)}:` : "";
+    return `/ws/${prefix}${canonical}`;
+  };
+  const getUrl = (baseUrl, opts) => {
+    const base = baseUrl.trim().replace(/\/+$/, "");
+    if (!base) throw new Error('realtimeServer: `getUrl` needs a base URL (e.g. "https://x.dev.xano.io").');
+    const socketBase = /^wss?:\/\//i.test(base) ? base : /^https?:\/\//i.test(base) ? base.replace(/^http/i, "ws") : `wss://${base}`;
+    assertNotResolvedSocketBase("getUrl", socketBase, base);
+    const lifted = liftTenantFromBase(socketBase, opts?.tenant);
+    return `${lifted.base}${getPath({ ...opts, tenant: lifted.tenant })}`;
+  };
+  return { ...def, getCanonical, getPath, getUrl };
+}
+
+// src/kinds/realtime-message.ts
+function resolveHost(def) {
+  const context = `realtimeMessage "${def.name}"`;
+  if (!def.channel) throw new Error(`${context}: \`channel\` is required.`);
+  const handle = typeof def.channel === "string" ? void 0 : def.channel;
+  if (!handle && def.server === void 0) {
+    throw new Error(
+      `${context}: \`server\` is required when \`channel\` is a bare path \u2014 a channel path is unique only within its realtime server, so "${def.channel}" alone is ambiguous. Pass the \`realtimeChannel()\` handle instead and the server comes with it.`
+    );
+  }
+  const server = def.server ?? handle.server;
+  const serverName = realtimeServerRefName(context, server);
+  if (handle && def.server !== void 0) {
+    const fromHandle = realtimeServerRefName(context, handle.server);
+    if (fromHandle !== serverName) {
+      throw new Error(
+        `${context}: \`server\` is "${serverName}" but the channel handle belongs to "${fromHandle}". Remove \`server\` (the handle already carries it) or bind the message to a channel on "${serverName}".`
+      );
+    }
+  }
+  return {
+    channel: handle ?? { name: def.channel, server },
+    server,
+    serverName
+  };
+}
+function realtimeMessageGuid(def) {
+  if (def.guid) return def.guid;
+  const { channel, serverName } = resolveHost(def);
+  return deriveGuid("message", realtimeMessageSeedName(serverName, channel.name, def.name));
+}
+function encodeRealtimeMessage(def) {
+  if (!def.name) throw new Error("realtimeMessage: `name` is required.");
+  assertStoredName(`realtimeMessage "${def.name}"`, def.name, "plain");
+  const host = resolveHost(def);
+  const channelId = realtimeChannelGuid(host.channel);
+  const serverId = resolveRealtimeServerRef(`realtimeMessage "${def.name}"`, host.server);
+  return {
+    name: def.name,
+    description: def.description ?? "",
+    active: def.active ?? true,
+    channel: { id: channelId },
+    server: { id: serverId },
+    auth: resolveAuthRef("realtimeMessage", def.name, def.auth),
+    deliver_to: def.deliverTo ?? "channel",
+    input: Object.entries(def.input ?? {}).map(([name, d]) => encodeInput(name, d)),
+    output: [],
+    middleware: buildMiddlewareBlock(def.middleware),
+    run: (def.stack ?? []).map(encodeStatement),
+    result: encodeResponse(def.response),
+    history: encodeHistory("message", def.history),
+    disabled: def.disabled ?? false,
+    tag: encodeTags(def.tags)
+  };
+}
+var realtimeMessageKind = {
+  name: "message",
+  payloadKey: "message",
+  encode: encodeRealtimeMessage,
+  guidOf: (def) => realtimeMessageGuid(def)
+};
+registerKind(realtimeMessageKind);
+function realtimeMessage(def) {
+  return def;
+}
+
+// src/kinds/task.ts
+var SCHEDULE_INSTANT = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})$/;
+function assertScheduleInstant(field, value) {
+  if (value === void 0) return;
+  const wellShaped = SCHEDULE_INSTANT.test(value);
+  const parsed = wellShaped ? Date.parse(value) : NaN;
+  if (wellShaped && !Number.isNaN(parsed)) return;
+  throw new Error(
+    `task schedule: \`${field}\` is ${JSON.stringify(value)}, which is not a schedule instant. Write it as "2026-01-01T00:00:00Z" \u2014 a date, a "T" (or a space), a time, and a ZONE ("Z", "+02:00" or "+0000"). The zone is the part most often left off, and without it the value is not an instant at all. The engine stores this string verbatim and does not validate it: a value it cannot parse deploys successfully and the task then never fires, which is indistinguishable from a task whose time has not come yet.`
+  );
+}
+function encodeSchedule(def) {
+  assertScheduleInstant("startsOn", def.startsOn);
+  assertScheduleInstant("endsOn", def.endsOn);
+  return {
+    starts_on: def.startsOn,
+    repeat: {
+      enabled: def.repeatEnabled ?? def.freq != null,
+      ends: { enabled: def.endsEnabled ?? def.endsOn != null, on: def.endsOn ?? def.startsOn },
+      freq: def.freq ?? 86400
+    }
+  };
+}
+function encodeTask(def) {
+  if (!def.name) throw new Error("task: `name` is required.");
+  return {
+    name: def.name,
+    description: def.description ?? "",
+    docs: def.docs ?? "",
+    datasource: def.datasource ?? "",
+    active: def.active ?? false,
+    middleware: buildMiddlewareBlock(def.middleware),
+    tag: encodeTags(def.tags),
+    history: encodeHistory("task", def.history),
+    run: (def.stack ?? []).map(encodeStatement),
+    schedule: (def.schedule ?? []).map(encodeSchedule)
+  };
+}
+var taskKind = {
+  name: "task",
+  payloadKey: "task",
+  encode: encodeTask
+};
+registerKind(taskKind);
+function task(def) {
+  return def;
+}
+
+// src/kinds/workflow-test.ts
+function encodeWorkflowTest(def) {
+  if (!def.name) throw new Error("workflow test: `name` is required.");
+  const datasource = def.datasource ?? "";
+  warnLiveDatasource({
+    code: "workflow-test.live-datasource",
+    subject: `workflow test "${def.name}"`,
+    datasource
+  });
+  return {
+    name: def.name,
+    description: def.description ?? "",
+    docs: def.docs ?? "",
+    datasource,
+    active: def.active ?? true,
+    tag: encodeTags(def.tags),
+    run: (def.stack ?? []).map(encodeStatement)
+  };
+}
+var workflowTestKind = {
+  name: "workflow_test",
+  payloadKey: "workflow_test",
+  encode: encodeWorkflowTest
+};
+registerKind(workflowTestKind);
+function workflowTest(def) {
+  return def;
+}
+
+// src/kinds/middleware.ts
+function encodeMiddleware(def) {
+  if (!def.name) throw new Error("middleware: `name` is required.");
+  const xdo = {
+    name: def.name,
+    description: def.description ?? "",
+    docs: def.docs ?? "",
+    result_type: def.resultStrategy ?? "merge",
+    exception: def.exceptionPolicy ?? "rethrow",
+    history: encodeHistory("middleware", def.history),
+    tag: encodeTags(def.tags),
+    shared_workspace: { is_shared: false },
+    input: Object.entries(def.input ?? {}).map(([name, d]) => encodeInput(name, d)),
+    result: encodeResponse(def.response),
+    run: (def.stack ?? []).map(encodeStatement),
+    test: encodeTests(def.tests, "middleware", def.name)
+  };
+  resolveMockKeys(xdo.run, xdo.test, "middleware", def.name);
+  return xdo;
+}
+var middlewareKind = {
+  name: "middleware",
+  payloadKey: "middleware",
+  encode: encodeMiddleware
+};
+registerKind(middlewareKind);
+function middlewareImpl(def) {
+  return def;
+}
+var middleware = Object.assign(middlewareImpl, { clear });
+
+// src/kinds/addon.ts
+function buildContext(def) {
+  const ctx = { ...def.context ?? {} };
+  if (def.table !== void 0 && ctx.dbo === void 0) {
+    ctx.dbo = def.table === null ? { as: def.tableAlias ?? "", id: "" } : {
+      id: resolveRef("dbo", def.table),
+      // Absent unless authored — writing it unconditionally would change the
+      // bytes of every addon that omits it today.
+      ...def.tableAlias !== void 0 ? { as: def.tableAlias } : {}
+    };
+  }
+  if (def.where !== void 0 && ctx.search === void 0) {
+    const search = encodeSearch(def.where);
+    if (search !== void 0) ctx.search = search;
+  }
+  if (def.sort !== void 0 && ctx.sort === void 0) {
+    const sort = encodeSort(def.sort);
+    if (sort.length) ctx.sort = sort;
+  }
+  const explicitReturn = ctx.return;
+  if (def.cardinality !== void 0 && explicitReturn?.type !== void 0 && explicitReturn.type !== def.cardinality) {
+    throw new Error(
+      `addon: cardinality:"${def.cardinality}" conflicts with an explicit context.return.type "${explicitReturn.type}" \u2014 they shape the graft differently. Set one, not both.`
+    );
+  }
+  if (def.cardinality !== void 0 && def.cardinality !== "list" && ctx.return === void 0) {
+    if (def.cardinality === "aggregate") {
+      const addonAlias = def.table === void 0 || def.table === null ? ctx.dbo?.as ?? "" : typeof def.table === "string" ? def.table : def.table.name;
+      ctx.return = {
+        type: "aggregate",
+        aggregate: {
+          sort: encodeSort(def.sort),
+          eval: encodeEval(qualifyAggregateEvals(def.eval, addonAlias, "eval")) ?? [],
+          group: encodeEval(qualifyAggregateEvals(def.group, addonAlias, "group")) ?? []
+        }
+      };
+    } else {
+      ctx.return = { type: def.cardinality };
+    }
+  }
+  return ctx;
+}
+function buildOutput(output) {
+  if (!output) return { customize: false, items: [] };
+  if (Array.isArray(output)) {
+    return { customize: true, items: output.map((name) => ({ name })) };
+  }
+  const block = output;
+  return { customize: block.customize ?? false, items: block.items ?? [] };
+}
+function encodeAddon(def) {
+  if (!def.name) throw new Error("addon: `name` is required.");
+  return {
+    name: def.name,
+    description: def.description ?? "",
+    context: buildContext(def),
+    output: buildOutput(def.output),
+    tag: encodeTags(def.tags),
+    input: Object.entries(def.input ?? {}).map(([name, d]) => encodeInput(name, d))
+  };
+}
+var addonKind = {
+  name: "addon",
+  payloadKey: "addon",
+  encode: encodeAddon
+};
+registerKind(addonKind);
+function addon(def) {
+  return def;
+}
+
+export {
+  encodeTool,
+  toolKind,
+  tool,
+  encodeToolRefs,
+  resolveToolsetCanonical,
+  encodeToolsetBase,
+  encodeAgent,
+  agentKind,
+  agent,
+  encodeMcpServer,
+  mcpServerKind,
+  mcpServer,
+  encodeApiGroup,
+  apiGroupKind,
+  apiGroup,
+  resolveRealtimeServerCanonical,
+  encodeRealtimeServer,
+  realtimeServerKind,
+  realtimeServer,
+  realtimeMessageGuid,
+  encodeRealtimeMessage,
+  realtimeMessageKind,
+  realtimeMessage,
+  encodeSchedule,
+  encodeTask,
+  taskKind,
+  task,
+  encodeWorkflowTest,
+  workflowTestKind,
+  workflowTest,
+  encodeMiddleware,
+  middlewareKind,
+  middleware,
+  encodeAddon,
+  addonKind,
+  addon
+};
+//# sourceMappingURL=chunk-YDZYMZBE.js.map