@kindgi/client 0.0.0-bootstrap.0 → 0.1.0

package/dist/index.js

@@ -0,0 +1,3800 @@
+// src/errors.ts
+function notImplementedInPreview(method) {
+  return {
+    code: "not-implemented-in-preview",
+    message: `${method}: transport not implemented in this preview`,
+    method
+  };
+}
+function notYetWired(method, reason) {
+  return {
+    code: "not-yet-wired",
+    message: `${method}: ${reason}`,
+    method,
+    reason
+  };
+}
+function fromWire(body) {
+  if (!body || typeof body !== "object") {
+    return {
+      code: "server",
+      serverCode: "unknown",
+      message: "Malformed error body from server"
+    };
+  }
+  const obj = body;
+  const code = typeof obj.code === "string" ? obj.code : "unknown";
+  const message = typeof obj.message === "string" ? obj.message : `Server error: ${code}`;
+  const details = obj.details && typeof obj.details === "object" ? obj.details : void 0;
+  switch (code) {
+    case "auth":
+      return {
+        code: "auth",
+        message,
+        reason: obj.reason ?? "unauthenticated"
+      };
+    // Wire-level auth codes per API-ROUTE-CONVENTIONS §4.3.
+    case "auth-missing":
+      return { code: "auth", message, reason: "unauthenticated" };
+    case "auth-expired":
+      return { code: "auth", message, reason: "token-expired" };
+    case "auth-revoked":
+      return { code: "auth", message, reason: "unauthenticated" };
+    case "permission-denied":
+      return { code: "auth", message, reason: "forbidden" };
+    case "rate-limited":
+    case "rate-limit-exceeded":
+      return {
+        code: "rate-limited",
+        message,
+        ...typeof obj.retryAfterSeconds === "number" ? { retryAfterSeconds: obj.retryAfterSeconds } : {}
+      };
+    case "not-found":
+    case "run-not-found":
+    case "agent-not-found":
+    case "tool-not-found":
+    case "guardrail-not-found":
+    case "flow-not-found":
+    case "conversation-not-found":
+    case "approval-not-found":
+    case "reviewer-not-found":
+    case "proposal-not-found":
+    case "provenance-not-found":
+    case "observation-not-found":
+    case "blob-not-found":
+    case "audit-bundle-not-found":
+    case "signing-not-configured":
+    case "signing-key-not-found":
+    case "adapter-not-found":
+    case "fact-not-found":
+    case "identity-user-not-found":
+    case "provider-not-found":
+    case "capability-not-found":
+    case "token-not-found":
+      return {
+        code: "not-found",
+        message,
+        resource: {
+          kind: code.replace(/-not-found$/u, "") || "unknown",
+          id: readStringField(
+            details,
+            "agentId",
+            "toolId",
+            "runId",
+            "adapterId",
+            "userId",
+            "providerId",
+            "capabilityId",
+            "tokenId",
+            "factId",
+            "guardrailId",
+            "id"
+          ) ?? "unknown"
+        }
+      };
+    case "conflict":
+    case "already-terminal":
+    case "run-already-terminal":
+    case "idempotency-key-body-mismatch":
+    case "hitl-required":
+    case "agent-already-registered":
+    case "tool-already-registered":
+    case "guardrail-already-registered":
+    case "flow-already-registered":
+    case "conversation-closed":
+    case "provider-already-registered":
+    case "proposal-invalid-state-transition":
+    case "approval-not-decided":
+      return { code: "conflict", message, reason: code };
+    case "invalid-request":
+    case "validation-failed":
+    case "unknown-field":
+    case "bad-input":
+    case "unresolved-tool":
+    case "unresolved-guardrail":
+    case "schema-validation-failed":
+    case "invalid-agent":
+    case "invalid-tool-definition":
+    case "invalid-schema":
+    case "unknown-effect":
+    case "invalid-guardrail":
+    case "invalid-provider":
+    case "supervisor-header-missing":
+      return {
+        code: "invalid-request",
+        message,
+        issues: obj.issues ?? details?.issues ?? []
+      };
+    case "guardrail-violation":
+      return {
+        code: "guardrail-violation",
+        message,
+        violations: readGuardrailViolations(details?.violations),
+        evaluationErrors: readEvaluationErrors(details?.evaluationErrors)
+      };
+    default:
+      return {
+        code: "server",
+        serverCode: code,
+        message,
+        ...details !== void 0 ? { fields: details } : {}
+      };
+  }
+}
+function readStringField(obj, ...keys) {
+  if (obj === void 0) return void 0;
+  for (const key of keys) {
+    const v = obj[key];
+    if (typeof v === "string" && v.length > 0) return v;
+  }
+  return void 0;
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" ? value : void 0;
+}
+function readGuardrailViolations(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const entry of raw) {
+    const v = asRecord(entry);
+    if (v === void 0 || typeof v.guardrailId !== "string") continue;
+    const reason = asRecord(v.result)?.reason;
+    out.push({
+      guardrailId: v.guardrailId,
+      severity: typeof v.severity === "string" ? v.severity : "unknown",
+      action: typeof v.action === "string" ? v.action : "unknown",
+      ...typeof reason === "string" && { reason }
+    });
+  }
+  return out;
+}
+function readEvaluationErrors(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const entry of raw) {
+    const e = asRecord(entry);
+    if (e === void 0 || typeof e.guardrailId !== "string") continue;
+    out.push({
+      guardrailId: e.guardrailId,
+      message: typeof e.message === "string" ? e.message : ""
+    });
+  }
+  return out;
+}
+var KindgiApiError = class extends Error {
+  error;
+  constructor(error) {
+    super(error.message);
+    this.name = "KindgiApiError";
+    this.error = error;
+  }
+};
+
+// src/streaming.ts
+async function* readSse(options) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const initialBackoff = options.initialBackoffMs ?? 500;
+  const maxBackoff = options.maxBackoffMs ?? 3e4;
+  const shouldRetry = options.shouldRetry ?? ((attempt2) => attempt2 < 10);
+  let lastEventId = options.lastEventId;
+  let attempt = 0;
+  while (!options.signal?.aborted) {
+    try {
+      const extra = typeof options.headers === "function" ? await options.headers() : options.headers ?? {};
+      const headers = {
+        Accept: "text/event-stream",
+        ...extra
+      };
+      if (lastEventId !== void 0) headers["Last-Event-Id"] = lastEventId;
+      const response = await fetchImpl(options.url, {
+        method: "GET",
+        headers,
+        ...options.signal ? { signal: options.signal } : {}
+      });
+      if (!response.ok || response.body === null) {
+        throw new SseHttpError(response.status);
+      }
+      attempt = 0;
+      for await (const event of parseSseStream(response.body)) {
+        if (event.id !== void 0) lastEventId = event.id;
+        yield event;
+      }
+      return;
+    } catch (err) {
+      if (options.signal?.aborted) return;
+      attempt += 1;
+      if (!shouldRetry(attempt, err)) throw err;
+      const backoff = Math.min(initialBackoff * 2 ** (attempt - 1), maxBackoff);
+      await sleep(backoff, options.signal);
+    }
+  }
+}
+var SseHttpError = class extends Error {
+  status;
+  constructor(status) {
+    super(`SSE upstream returned HTTP ${status}`);
+    this.name = "SseHttpError";
+    this.status = status;
+  }
+};
+async function* unwrapSseData(source) {
+  for await (const event of source) {
+    yield event.data;
+  }
+}
+async function* parseSseStream(body) {
+  const decoder = new TextDecoder();
+  const reader = body.getReader();
+  let buffer = "";
+  let eventName = "message";
+  let dataLines = [];
+  let eventId;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let newlineIdx = buffer.indexOf("\n");
+      while (newlineIdx !== -1) {
+        const line = buffer.slice(0, newlineIdx).replace(/\r$/, "");
+        buffer = buffer.slice(newlineIdx + 1);
+        newlineIdx = buffer.indexOf("\n");
+        if (line === "") {
+          if (dataLines.length > 0) {
+            const raw = dataLines.join("\n");
+            try {
+              const data = JSON.parse(raw);
+              yield { event: eventName, data, ...eventId !== void 0 ? { id: eventId } : {} };
+            } catch {
+            }
+          }
+          eventName = "message";
+          dataLines = [];
+          eventId = void 0;
+          continue;
+        }
+        if (line.startsWith(":")) continue;
+        const colonIdx = line.indexOf(":");
+        const field = colonIdx === -1 ? line : line.slice(0, colonIdx);
+        const rawVal = colonIdx === -1 ? "" : line.slice(colonIdx + 1);
+        const val = rawVal.startsWith(" ") ? rawVal.slice(1) : rawVal;
+        switch (field) {
+          case "event":
+            eventName = val;
+            break;
+          case "data":
+            dataLines.push(val);
+            break;
+          case "id":
+            eventId = val;
+            break;
+          default:
+            break;
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function* postSse(options) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const headers = {
+    Accept: "text/event-stream",
+    ...options.body !== void 0 && { "Content-Type": "application/json" },
+    ...options.headers ?? {}
+  };
+  const response = await fetchImpl(options.url, {
+    method: "POST",
+    headers,
+    ...options.body !== void 0 && { body: JSON.stringify(options.body) },
+    ...options.signal ? { signal: options.signal } : {}
+  });
+  if (!response.ok || response.body === null) {
+    throw new Error(`SSE upstream returned HTTP ${response.status}`);
+  }
+  for await (const event of parseSseStream(response.body)) {
+    yield event;
+  }
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(t);
+        resolve();
+      },
+      { once: true }
+    );
+  });
+}
+
+// src/resources/adapters.ts
+function makeAdaptersClient(transport) {
+  return {
+    async list(filter) {
+      const page = await transport.request({
+        method: "GET",
+        path: "/v1/adapters",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.kind !== void 0 && { kind: filter.kind },
+          ...filter?.status !== void 0 && { status: filter.status }
+        }
+      });
+      return {
+        items: page.data,
+        ...page.nextCursor !== void 0 && { nextCursor: page.nextCursor }
+      };
+    },
+    async get(adapterId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/adapters/${encodeURIComponent(adapterId)}`
+      });
+    },
+    async test(input) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/adapters/${encodeURIComponent(input.adapterId)}/test`,
+        body: input.probe ?? {},
+        ...input.idempotencyKey !== void 0 && { idempotencyKey: input.idempotencyKey }
+      });
+    },
+    prepare(input) {
+      const url = `${transport.apiUrl}/v1/adapters/${encodeURIComponent(input.adapterId)}/prepare`;
+      const source = postSse({
+        url,
+        headers: transport.authHeaders(),
+        fetchImpl: transport.fetchImpl,
+        ...input.params !== void 0 && { body: { params: input.params } },
+        ...input.signal !== void 0 && { signal: input.signal }
+      });
+      return unwrapSseData(source);
+    },
+    async candidates() {
+      throw new KindgiApiError(
+        notYetWired(
+          "adapters.candidates",
+          "no /v1/adapters/candidates route on the API \u2014 deployment-wired set is authoritative, no upstream catalog surface"
+        )
+      );
+    },
+    async configured() {
+      throw new KindgiApiError(
+        notYetWired(
+          "adapters.configured",
+          "use adapters.list() \u2014 the record-by-kind shape does not map to the wire paginated list"
+        )
+      );
+    },
+    async configure(_input) {
+      throw new KindgiApiError(
+        notYetWired(
+          "adapters.configure",
+          "adapters are wired at boot via config-as-code; runtime rebinding requires a platform capability that has not landed"
+        )
+      );
+    }
+  };
+}
+
+// src/resources/agents.ts
+function makeAgentsClient(transport) {
+  const seg = (s) => encodeURIComponent(s);
+  return {
+    async define(spec, options) {
+      const result = await transport.request({
+        method: "POST",
+        path: "/v1/agents",
+        body: { ...spec, projectId: options.projectId },
+        ...options.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+      return result.agentId;
+    },
+    async list(filter) {
+      return transport.request({
+        method: "GET",
+        path: "/v1/agents",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.name !== void 0 && { name: filter.name }
+        }
+      });
+    },
+    async get(agentId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/agents/${seg(agentId)}`
+      });
+    },
+    versions: {
+      async list(agentId, filter) {
+        return transport.request({
+          method: "GET",
+          path: `/v1/agents/${seg(agentId)}/versions`,
+          query: {
+            ...filter?.limit !== void 0 && { limit: filter.limit },
+            ...filter?.cursor !== void 0 && { cursor: filter.cursor }
+          }
+        });
+      },
+      async get(agentId, version) {
+        return transport.request({
+          method: "GET",
+          path: `/v1/agents/${seg(agentId)}/versions/${seg(version)}`
+        });
+      },
+      async unregister(agentId, version, options) {
+        return transport.request({
+          method: "POST",
+          path: `/v1/agents/${seg(agentId)}/versions/${seg(version)}/unregister`,
+          ...options?.idempotencyKey !== void 0 && {
+            idempotencyKey: options.idempotencyKey
+          }
+        });
+      }
+    },
+    async reinstateVersion(agentId, version, options) {
+      const wire = await transport.request({
+        method: "POST",
+        path: `/v1/agents/${seg(agentId)}/versions/${seg(version)}/reinstate`,
+        ...options?.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+      return {
+        agentId: wire.agentId,
+        version: wire.version,
+        wasTombstoned: wire.wasTombstoned
+      };
+    }
+  };
+}
+
+// src/status-query.ts
+function singleStatusQuery(method, status) {
+  if (status === void 0) return void 0;
+  if (!Array.isArray(status)) return status;
+  const statuses = status;
+  if (statuses.length <= 1) return statuses[0];
+  const error = {
+    code: "invalid-request",
+    message: `${method}: filter by one status at a time; the API accepts a single \`status\` value`,
+    issues: [{ path: "/status", message: "expected a single status" }]
+  };
+  throw new KindgiApiError(error);
+}
+
+// src/resources/approvals.ts
+function makeApprovalsClient(transport) {
+  return {
+    async list(filter) {
+      const statusParam = singleStatusQuery("approvals.list", filter?.status);
+      const page = await transport.request({
+        method: "GET",
+        path: "/v1/approvals",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...statusParam !== void 0 && { status: statusParam },
+          ...filter?.requiredRole !== void 0 && { requiredRole: filter.requiredRole },
+          ...filter?.createdAfter !== void 0 && {
+            createdAfter: filter.createdAfter
+          }
+        }
+      });
+      return {
+        items: page.data,
+        ...page.nextCursor !== void 0 && {
+          nextCursor: page.nextCursor
+        }
+      };
+    },
+    async get(id) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/approvals/${encodeURIComponent(id)}`
+      });
+    },
+    async decide(id, input) {
+      const body = { decision: input.decision };
+      if (input.rationale !== void 0) body.rationale = input.rationale;
+      if (input.value !== void 0) body.value = input.value;
+      return transport.request({
+        method: "POST",
+        path: `/v1/approvals/${encodeURIComponent(id)}/complete`,
+        body,
+        ...input.idempotencyKey !== void 0 && { idempotencyKey: input.idempotencyKey }
+      });
+    },
+    async batch(_input) {
+      throw new KindgiApiError(
+        notYetWired(
+          "approvals.batch",
+          "no bulk-decide route on the API \u2014 per-approval POST /v1/approvals/{id}/complete is the primitive; a bulk wrapper needs a design on partial-failure semantics"
+        )
+      );
+    },
+    async assign(_id, _reviewerId) {
+      throw new KindgiApiError(
+        notYetWired(
+          "approvals.assign",
+          "no per-approval assign route on the API \u2014 assignment happens at approval-creation time via HITL binding resolveReviewer, external re-assign is a planned follow-up"
+        )
+      );
+    },
+    async completeToken(_id, _input) {
+      throw new KindgiApiError(
+        notYetWired(
+          "approvals.completeToken",
+          "no standalone complete-token route on the API \u2014 wire fuses waitpoint resume into POST /v1/approvals/{id}/complete (any decide that terminates + carries a waitTokenId auto-resumes), use approvals.decide instead"
+        )
+      );
+    },
+    reviewers: {
+      async register(spec, options) {
+        return transport.request({
+          method: "POST",
+          path: "/v1/approvals/reviewers",
+          body: {
+            userId: spec.userId,
+            role: spec.role,
+            ...spec.displayName !== void 0 && { displayName: spec.displayName }
+          },
+          ...options?.idempotencyKey !== void 0 && {
+            idempotencyKey: options.idempotencyKey
+          }
+        });
+      },
+      async list(filter) {
+        const page = await transport.request({
+          method: "GET",
+          path: "/v1/approvals/reviewers",
+          query: {
+            ...filter?.limit !== void 0 && { limit: filter.limit },
+            ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+            ...filter?.role !== void 0 && { role: filter.role }
+          }
+        });
+        return {
+          items: page.data,
+          ...page.nextCursor !== void 0 && {
+            nextCursor: page.nextCursor
+          }
+        };
+      },
+      async get(id) {
+        return transport.request({
+          method: "GET",
+          path: `/v1/approvals/reviewers/${encodeURIComponent(id)}`
+        });
+      },
+      async updateRole(_id, _role) {
+        throw new KindgiApiError(
+          notYetWired(
+            "approvals.reviewers.updateRole",
+            "no dedicated update-role route on the API \u2014 role rotation happens via re-register (idempotent per (tenantId, userId) rewrites the role), wire only if a bespoke audit-log entry for role changes is needed"
+          )
+        );
+      },
+      async deactivate(id, options) {
+        return transport.request({
+          method: "POST",
+          path: `/v1/approvals/reviewers/${encodeURIComponent(id)}/unregister`,
+          body: {},
+          ...options?.idempotencyKey !== void 0 && {
+            idempotencyKey: options.idempotencyKey
+          }
+        });
+      }
+    },
+    audit: {
+      async export(input) {
+        return transport.request({
+          method: "POST",
+          path: `/v1/approvals/${encodeURIComponent(input.approvalId)}/audit-bundle`,
+          body: {
+            signingKeyId: input.signingKeyId,
+            ...input.includeMessages !== void 0 && {
+              includeMessages: input.includeMessages
+            }
+          },
+          ...input.idempotencyKey !== void 0 && { idempotencyKey: input.idempotencyKey }
+        });
+      },
+      async get(_id) {
+        throw new KindgiApiError(
+          notYetWired(
+            "approvals.audit.get",
+            "no GET /v1/audit-bundles/{id} route on the API \u2014 wire ships the signed body inline from export (bundles are not durably stored server-side today)"
+          )
+        );
+      },
+      async list(_filter) {
+        throw new KindgiApiError(
+          notYetWired(
+            "approvals.audit.list",
+            "no GET /v1/audit-bundles route on the API \u2014 bundles are not durably stored server-side today"
+          )
+        );
+      },
+      async verify(_bundle, _publicKey) {
+        throw new KindgiApiError(
+          notYetWired(
+            "approvals.audit.verify",
+            "client-side verifier requires the crypto module reachability from the SDK bundle \u2014 not yet vendored (same constraint as provenance.verify + webhooks.verify)"
+          )
+        );
+      }
+    }
+  };
+}
+
+// src/resources/artifacts.ts
+function makeArtifactsClient(transport) {
+  return {
+    async put(_input) {
+      throw new KindgiApiError(
+        notYetWired(
+          "artifacts.put",
+          "POST /v1/artifacts is a multipart-form upload; the SDK transport is JSON-only. Multipart / raw-stream body support is a planned follow-up"
+        )
+      );
+    },
+    async get(_ref) {
+      throw new KindgiApiError(
+        notYetWired(
+          "artifacts.get",
+          "GET /v1/artifacts/{blobId} streams binary bytes; the SDK transport hydrates JSON only. Raw-stream response support is a planned follow-up"
+        )
+      );
+    },
+    async list(filter) {
+      const page = await transport.request({
+        method: "GET",
+        path: "/v1/artifacts",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.ownerRunId !== void 0 && {
+            ownerRunId: filter.ownerRunId
+          },
+          ...filter?.contentType !== void 0 && { contentType: filter.contentType }
+        }
+      });
+      return {
+        items: page.data,
+        ...page.nextCursor !== void 0 && {
+          nextCursor: page.nextCursor
+        }
+      };
+    },
+    async delete(blobId, options) {
+      return transport.request({
+        method: "DELETE",
+        path: `/v1/artifacts/${encodeURIComponent(blobId)}`,
+        ...options?.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+    },
+    async presign(_input) {
+      throw new KindgiApiError(
+        notYetWired(
+          "artifacts.presign",
+          "no POST /v1/artifacts/presign route on the API \u2014 presigned URLs are a per-backend concern (S3/GCS/R2 native)"
+        )
+      );
+    },
+    async setRetentionLock(_ref, _until) {
+      throw new KindgiApiError(
+        notYetWired(
+          "artifacts.setRetentionLock",
+          "no POST /v1/artifacts/{blobId}/retention-lock route on the API \u2014 retention locks are a per-backend concern (S3 Object Lock, MinIO retention)"
+        )
+      );
+    }
+  };
+}
+
+// src/resources/audit.ts
+function makeAuditClient(transport) {
+  return {
+    authz: {
+      async list(filter) {
+        return transport.request({
+          method: "GET",
+          path: "/v1/audit/authz",
+          query: {
+            ...filter?.limit !== void 0 && { limit: filter.limit },
+            ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+            ...filter?.actorSubject !== void 0 && { actorSubject: filter.actorSubject },
+            ...filter?.onBehalfOf !== void 0 && { onBehalfOf: filter.onBehalfOf },
+            ...filter?.action !== void 0 && { action: filter.action },
+            ...filter?.resource !== void 0 && { resource: filter.resource },
+            ...filter?.outcome !== void 0 && { outcome: filter.outcome },
+            ...filter?.runId !== void 0 && { runId: filter.runId },
+            ...filter?.from !== void 0 && { from: filter.from },
+            ...filter?.to !== void 0 && { to: filter.to }
+          }
+        });
+      }
+    }
+  };
+}
+
+// src/resources/auth.ts
+function makeAuthClient(transport) {
+  const seg = (s) => encodeURIComponent(s);
+  return {
+    providers: {
+      async list() {
+        return transport.request({
+          method: "GET",
+          path: "/v1/auth/providers"
+        });
+      },
+      async register(input, options) {
+        return transport.request({
+          method: "POST",
+          path: "/v1/auth/providers",
+          body: input,
+          ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+        });
+      },
+      async unregister(providerId, options) {
+        return transport.request({
+          method: "POST",
+          path: `/v1/auth/providers/${seg(providerId)}/unregister`,
+          ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+        });
+      }
+    },
+    async login(providerId, input, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/auth/login/${seg(providerId)}`,
+        ...input !== void 0 && { body: input },
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async callback(providerId, input) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/auth/callback/${seg(providerId)}`,
+        body: input
+      });
+    },
+    async refresh(options) {
+      return transport.request({
+        method: "POST",
+        path: "/v1/auth/refresh",
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async logout(options) {
+      return transport.request({
+        method: "POST",
+        path: "/v1/auth/logout",
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    }
+  };
+}
+
+// src/resources/capabilities.ts
+function makeCapabilitiesClient(transport) {
+  return {
+    async list(filter) {
+      const page = await transport.request({
+        method: "GET",
+        path: "/v1/capabilities",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.feature !== void 0 && { feature: filter.feature }
+        }
+      });
+      return {
+        items: page.data,
+        ...page.nextCursor !== void 0 && {
+          nextCursor: page.nextCursor
+        }
+      };
+    },
+    async get(capabilityId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/capabilities/${encodeURIComponent(capabilityId)}`
+      });
+    },
+    async route(_needs) {
+      throw new KindgiApiError(
+        notYetWired(
+          "capabilities.route",
+          "no POST /v1/capabilities/route route on the API \u2014 preview routing is a runtime primitive without an HTTP surface yet"
+        )
+      );
+    },
+    providers: {
+      async list(filter) {
+        const page = await transport.request({
+          method: "GET",
+          path: "/v1/providers",
+          query: {
+            ...filter?.limit !== void 0 && { limit: filter.limit },
+            ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+            ...filter?.feature !== void 0 && { feature: filter.feature }
+          }
+        });
+        return {
+          items: page.data,
+          ...page.nextCursor !== void 0 && {
+            nextCursor: page.nextCursor
+          }
+        };
+      },
+      async get(id) {
+        return transport.request({
+          method: "GET",
+          path: `/v1/providers/${encodeURIComponent(id)}`
+        });
+      },
+      async configure(spec, options) {
+        return transport.request({
+          method: "POST",
+          path: "/v1/providers",
+          body: spec,
+          ...options?.idempotencyKey !== void 0 && {
+            idempotencyKey: options.idempotencyKey
+          }
+        });
+      },
+      async capabilitiesFor(id) {
+        const envelope = await transport.request({
+          method: "GET",
+          path: `/v1/providers/${encodeURIComponent(id)}/capabilities`
+        });
+        return envelope.data;
+      },
+      async enable(_id) {
+        throw new KindgiApiError(
+          notYetWired(
+            "capabilities.providers.enable",
+            "no POST /v1/providers/{id}/enable route on the API \u2014 wire has no active/inactive state"
+          )
+        );
+      },
+      async disable(_id) {
+        throw new KindgiApiError(
+          notYetWired(
+            "capabilities.providers.disable",
+            "no POST /v1/providers/{id}/disable route on the API \u2014 wire has no active/inactive state"
+          )
+        );
+      },
+      async delete(id, options) {
+        return transport.request({
+          method: "POST",
+          path: `/v1/providers/${encodeURIComponent(id)}/unregister`,
+          body: {},
+          ...options?.idempotencyKey !== void 0 && {
+            idempotencyKey: options.idempotencyKey
+          }
+        });
+      }
+    }
+  };
+}
+
+// src/resources/compliance.ts
+function makeComplianceClient(transport) {
+  return {
+    evidence: {
+      async list(filter) {
+        return transport.request({
+          method: "GET",
+          path: "/v1/compliance/evidence",
+          query: {
+            ...filter?.limit !== void 0 && { limit: filter.limit },
+            ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+            ...filter?.runId !== void 0 && { runId: filter.runId },
+            ...filter?.agentId !== void 0 && { agentId: filter.agentId },
+            ...filter?.flowId !== void 0 && { flowId: filter.flowId },
+            ...filter?.kind !== void 0 && { kind: filter.kind },
+            ...filter?.from !== void 0 && { from: filter.from },
+            ...filter?.to !== void 0 && { to: filter.to }
+          }
+        });
+      },
+      async get(evidenceId) {
+        return transport.request({
+          method: "GET",
+          path: `/v1/compliance/evidence/${encodeURIComponent(evidenceId)}`
+        });
+      },
+      async export(input, options) {
+        return transport.request({
+          method: "POST",
+          path: "/v1/compliance/evidence/export",
+          body: input,
+          ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+        });
+      }
+    }
+  };
+}
+
+// src/resources/conversations.ts
+function makeConversationsClient(transport) {
+  return {
+    async open(input, options) {
+      return transport.request({
+        method: "POST",
+        path: "/v1/conversations",
+        body: {
+          agentId: input.agentId,
+          agentVersion: input.agentVersion,
+          ...input.title !== void 0 && { title: input.title },
+          ...input.scope !== void 0 && { scope: input.scope },
+          ...input.participantId !== void 0 && { participantId: input.participantId },
+          ...input.metadata !== void 0 && { metadata: input.metadata }
+        },
+        ...options?.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+    },
+    async get(id) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/conversations/${encodeURIComponent(id)}`
+      });
+    },
+    async list(filter) {
+      const statusParam = singleStatusQuery("conversations.list", filter?.status);
+      const page = await transport.request({
+        method: "GET",
+        path: "/v1/conversations",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...statusParam !== void 0 && { status: statusParam },
+          ...filter?.agent !== void 0 && { agentId: filter.agent }
+        }
+      });
+      return {
+        items: page.data,
+        ...page.nextCursor !== void 0 && { nextCursor: page.nextCursor }
+      };
+    },
+    async close(id, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/conversations/${encodeURIComponent(id)}/close`,
+        body: {},
+        ...options?.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+    },
+    async messages(id, filter) {
+      const page = await transport.request({
+        method: "GET",
+        path: `/v1/conversations/${encodeURIComponent(id)}/messages`,
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor }
+        }
+      });
+      return {
+        items: page.data,
+        ...page.nextCursor !== void 0 && { nextCursor: page.nextCursor }
+      };
+    }
+  };
+}
+
+// src/resources/cost.ts
+function makeCostClient(transport) {
+  return {
+    usage: {
+      async query(filter) {
+        const page = await transport.request({
+          method: "GET",
+          path: "/v1/cost/records",
+          query: {
+            ...filter?.limit !== void 0 && { limit: filter.limit },
+            ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+            ...filter?.runId !== void 0 && { runId: filter.runId },
+            ...filter?.agentId !== void 0 && { agentId: filter.agentId },
+            ...filter?.conversationId !== void 0 && {
+              conversationId: filter.conversationId
+            },
+            ...filter?.category !== void 0 && { category: filter.category },
+            ...filter?.providerId !== void 0 && {
+              providerId: filter.providerId
+            },
+            ...filter?.from !== void 0 && { from: filter.from },
+            ...filter?.to !== void 0 && { to: filter.to }
+          }
+        });
+        return {
+          items: page.data,
+          ...page.nextCursor !== void 0 && {
+            nextCursor: page.nextCursor
+          }
+        };
+      },
+      async get(recordId) {
+        return transport.request({
+          method: "GET",
+          path: `/v1/cost/records/${encodeURIComponent(recordId)}`
+        });
+      },
+      async summary(input) {
+        return transport.request({
+          method: "GET",
+          path: "/v1/cost/aggregate",
+          query: {
+            from: input.from,
+            to: input.to,
+            ...input.groupBy !== void 0 && { groupBy: input.groupBy.join(",") },
+            ...input.category !== void 0 && { category: input.category },
+            ...input.providerId !== void 0 && {
+              providerId: input.providerId
+            },
+            ...input.agentId !== void 0 && { agentId: input.agentId },
+            ...input.runId !== void 0 && { runId: input.runId },
+            ...input.conversationId !== void 0 && {
+              conversationId: input.conversationId
+            }
+          }
+        });
+      }
+    },
+    budgets: {
+      async get() {
+        throw new KindgiApiError(
+          notYetWired(
+            "cost.budgets.get",
+            "no GET /v1/tenant/budgets route on the API \u2014 budget enforcement primitive not surfaced on the wire"
+          )
+        );
+      },
+      async set(_input) {
+        throw new KindgiApiError(
+          notYetWired(
+            "cost.budgets.set",
+            "no PUT /v1/tenant/budgets route on the API \u2014 admin-scope budget writes not surfaced yet"
+          )
+        );
+      },
+      async getRemaining() {
+        throw new KindgiApiError(
+          notYetWired(
+            "cost.budgets.getRemaining",
+            "no GET /v1/tenant/budgets/remaining route on the API \u2014 window-remaining computation not surfaced yet"
+          )
+        );
+      }
+    }
+  };
+}
+
+// src/resources/deployments.ts
+function makeDeploymentsClient(transport) {
+  return {
+    async register(input, options) {
+      return transport.request({
+        method: "POST",
+        path: "/v1/deployments",
+        body: input,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async list(filter) {
+      return transport.request({
+        method: "GET",
+        path: "/v1/deployments",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.imageRefPrefix !== void 0 && { imageRefPrefix: filter.imageRefPrefix },
+          ...filter?.signerKeyId !== void 0 && { signerKeyId: filter.signerKeyId }
+        }
+      });
+    },
+    async get(deploymentId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/deployments/${encodeURIComponent(deploymentId)}`
+      });
+    },
+    async syncSecrets(deploymentId, input, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/deployments/${encodeURIComponent(deploymentId)}/secrets`,
+        body: input,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    }
+  };
+}
+
+// src/scope-wire.ts
+function scopeForBody(scope) {
+  if (scope.kind === "tenant") return { kind: "tenant" };
+  if (scope.kind === "org") return { kind: "org", orgId: scope.orgId };
+  return { kind: "project", projectId: scope.projectId };
+}
+function scopeToQuery(scope) {
+  if (scope.kind === "tenant") return { scopeKind: "tenant" };
+  if (scope.kind === "org") {
+    return { scopeKind: "org", scopeId: scope.orgId };
+  }
+  return { scopeKind: "project", scopeId: scope.projectId };
+}
+
+// src/resources/env.ts
+function makeEnvClient(transport) {
+  return {
+    async list(input) {
+      const q = scopeToQuery(input.scope);
+      const page = await transport.request({
+        method: "GET",
+        path: "/v1/env",
+        query: {
+          envName: input.envName,
+          scopeKind: q.scopeKind,
+          ...q.scopeId !== void 0 && { scopeId: q.scopeId },
+          ...input.cursor !== void 0 && {
+            cursor: input.cursor
+          },
+          ...input.namePrefix !== void 0 && { namePrefix: input.namePrefix },
+          ...input.limit !== void 0 && { limit: input.limit }
+        }
+      });
+      return {
+        data: page.data,
+        ...page.nextCursor !== void 0 && {
+          nextCursor: page.nextCursor
+        }
+      };
+    },
+    async get(input) {
+      const q = scopeToQuery(input.scope);
+      try {
+        return await transport.request({
+          method: "GET",
+          path: `/v1/env/${encodeURIComponent(input.name)}`,
+          query: {
+            envName: input.envName,
+            scopeKind: q.scopeKind,
+            ...q.scopeId !== void 0 && { scopeId: q.scopeId }
+          }
+        });
+      } catch (err) {
+        if (isEnvNotFound(err)) return null;
+        throw err;
+      }
+    },
+    async set(input) {
+      const q = scopeToQuery(input.scope);
+      try {
+        const record = await transport.request({
+          method: "PUT",
+          path: `/v1/env/${encodeURIComponent(input.name)}`,
+          query: {
+            envName: input.envName,
+            scopeKind: q.scopeKind,
+            ...q.scopeId !== void 0 && { scopeId: q.scopeId }
+          },
+          body: {
+            scope: scopeForBody(input.scope),
+            envName: input.envName,
+            name: input.name,
+            value: input.value,
+            ...input.ifRevision !== void 0 && { ifRevision: input.ifRevision },
+            ...input.tags !== void 0 && { tags: input.tags }
+          }
+        });
+        return { kind: "ok", record };
+      } catch (err) {
+        const conflict = tryReadRevisionConflict(err);
+        if (conflict !== null) {
+          return { kind: "revision-conflict", currentRevision: conflict };
+        }
+        throw err;
+      }
+    },
+    async delete(input) {
+      const q = scopeToQuery(input.scope);
+      return transport.request({
+        method: "DELETE",
+        path: `/v1/env/${encodeURIComponent(input.name)}`,
+        query: {
+          envName: input.envName,
+          scopeKind: q.scopeKind,
+          ...q.scopeId !== void 0 && { scopeId: q.scopeId }
+        }
+      });
+    }
+  };
+}
+function isEnvNotFound(err) {
+  if (err === null || typeof err !== "object") return false;
+  const asAny = err;
+  const inner = asAny.error;
+  if (inner === void 0) return false;
+  const code = inner.code;
+  const serverCode = inner.serverCode;
+  if (code === "env-not-found") return true;
+  if (code === "not-found" && typeof inner.resource === "object" && inner.resource !== null && inner.resource.kind === "env") {
+    return true;
+  }
+  if (code === "server" && serverCode === "env-not-found") return true;
+  return false;
+}
+function tryReadRevisionConflict(err) {
+  if (err === null || typeof err !== "object") return null;
+  const asAny = err;
+  const inner = asAny.error;
+  if (inner === void 0) return null;
+  const isConflict = inner.code === "env-write-conflict" || inner.code === "conflict" || inner.serverCode === "env-write-conflict";
+  if (!isConflict) return null;
+  const fromFields = inner.fields?.currentRevision;
+  if (typeof fromFields === "number") return fromFields;
+  const cur = inner.currentRevision;
+  if (typeof cur !== "number") return null;
+  return cur;
+}
+
+// src/resources/eval-runs.ts
+function makeEvalRunsClient(transport) {
+  const seg = (s) => encodeURIComponent(s);
+  return {
+    async start(suiteId, input, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/eval-suites/${seg(suiteId)}/runs`,
+        body: { ...input, projectId: options.projectId },
+        ...options.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async list(filter) {
+      return transport.request({
+        method: "GET",
+        path: "/v1/eval-runs",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.suiteId !== void 0 && { suiteId: filter.suiteId },
+          ...filter?.status !== void 0 && { status: filter.status },
+          ...filter?.agentId !== void 0 && { agentId: filter.agentId }
+        }
+      });
+    },
+    async get(runId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/eval-runs/${seg(runId)}`
+      });
+    },
+    async cancel(runId) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/eval-runs/${seg(runId)}/cancel`
+      });
+    },
+    events(runId, options) {
+      const url = `${transport.apiUrl}/v1/eval-runs/${seg(runId)}/events`;
+      const source = readSse({
+        url,
+        headers: transport.authHeaders(),
+        fetchImpl: transport.fetchImpl,
+        ...options?.signal !== void 0 && { signal: options.signal },
+        ...options?.initialBackoffMs !== void 0 && {
+          initialBackoffMs: options.initialBackoffMs
+        },
+        ...options?.maxBackoffMs !== void 0 && {
+          maxBackoffMs: options.maxBackoffMs
+        }
+      });
+      return unwrapSseData(source);
+    }
+  };
+}
+
+// src/resources/eval-suites.ts
+function makeEvalSuitesClient(transport) {
+  const seg = (s) => encodeURIComponent(s);
+  return {
+    async publish(input, options) {
+      return transport.request({
+        method: "POST",
+        path: "/v1/eval-suites",
+        body: { ...input, projectId: options.projectId },
+        ...options.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async list(filter) {
+      return transport.request({
+        method: "GET",
+        path: "/v1/eval-suites",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.kind !== void 0 && { kind: filter.kind },
+          ...filter?.name !== void 0 && { name: filter.name },
+          ...filter?.scopeKind !== void 0 && { scopeKind: filter.scopeKind },
+          ...filter?.scopeId !== void 0 && { scopeId: filter.scopeId },
+          ...filter?.inherit !== void 0 && { inherit: filter.inherit }
+        }
+      });
+    },
+    async get(suiteId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/eval-suites/${seg(suiteId)}`
+      });
+    },
+    versions: {
+      async list(suiteId, filter) {
+        return transport.request({
+          method: "GET",
+          path: `/v1/eval-suites/${seg(suiteId)}/versions`,
+          query: {
+            ...filter?.limit !== void 0 && { limit: filter.limit },
+            ...filter?.cursor !== void 0 && { cursor: filter.cursor }
+          }
+        });
+      },
+      async get(suiteId, version) {
+        return transport.request({
+          method: "GET",
+          path: `/v1/eval-suites/${seg(suiteId)}/versions/${seg(version)}`
+        });
+      },
+      async unregister(suiteId, version, options) {
+        return transport.request({
+          method: "POST",
+          path: `/v1/eval-suites/${seg(suiteId)}/versions/${seg(version)}/unregister`,
+          ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+        });
+      },
+      async reinstate(suiteId, version, options) {
+        return transport.request({
+          method: "POST",
+          path: `/v1/eval-suites/${seg(suiteId)}/versions/${seg(version)}/reinstate`,
+          ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+        });
+      }
+    }
+  };
+}
+
+// src/resources/event-triggers.ts
+function makeEventTriggersClient(transport) {
+  return {
+    async register(input, options) {
+      return transport.request({
+        method: "POST",
+        path: "/v1/event-triggers",
+        body: input,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async list(filter) {
+      return transport.request({
+        method: "GET",
+        path: "/v1/event-triggers",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.status !== void 0 && { status: filter.status }
+        }
+      });
+    },
+    async get(triggerId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/event-triggers/${encodeURIComponent(triggerId)}`
+      });
+    },
+    async update(triggerId, input, options) {
+      return transport.request({
+        method: "PATCH",
+        path: `/v1/event-triggers/${encodeURIComponent(triggerId)}`,
+        body: input,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async pause(triggerId, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/event-triggers/${encodeURIComponent(triggerId)}/pause`,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async resume(triggerId, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/event-triggers/${encodeURIComponent(triggerId)}/resume`,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async unregister(triggerId, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/event-triggers/${encodeURIComponent(triggerId)}/unregister`,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    }
+  };
+}
+
+// src/resources/events.ts
+function makeEventsClient(_transport) {
+  return {
+    async emit(_spec) {
+      throw new KindgiApiError(
+        notYetWired(
+          "events.emit",
+          "no POST /v1/events route on the API \u2014 outbound event-emit surface has not landed (runtime event-bus primitive is live; HTTP surface pending)"
+        )
+      );
+    },
+    async subscribe(_spec) {
+      throw new KindgiApiError(
+        notYetWired(
+          "events.subscribe",
+          "no POST /v1/events/subscriptions route on the API \u2014 subscription registration surface has not landed"
+        )
+      );
+    },
+    subscriptions: {
+      async list() {
+        throw new KindgiApiError(
+          notYetWired(
+            "events.subscriptions.list",
+            "no GET /v1/events/subscriptions route on the API"
+          )
+        );
+      },
+      async get(_id) {
+        throw new KindgiApiError(
+          notYetWired(
+            "events.subscriptions.get",
+            "no GET /v1/events/subscriptions/{id} route on the API"
+          )
+        );
+      },
+      async delete(_id) {
+        throw new KindgiApiError(
+          notYetWired(
+            "events.subscriptions.delete",
+            "no DELETE /v1/events/subscriptions/{id} route on the API"
+          )
+        );
+      }
+    },
+    stream(_subscriptionId) {
+      const iter = {
+        // eslint-disable-next-line @typescript-eslint/require-await
+        [Symbol.asyncIterator]() {
+          return {
+            next() {
+              return Promise.reject(
+                new KindgiApiError(
+                  notYetWired(
+                    "events.stream",
+                    "no GET /v1/events/subscriptions/{id}/stream route on the API \u2014 subscription-scoped SSE surface has not landed (runtime event bus is live; SDK-side SSE reader is ready via readSse; HTTP route pending). Use client.runs.stream(runId) for live run-scoped events."
+                  )
+                )
+              );
+            }
+          };
+        }
+      };
+      return iter;
+    },
+    async query(_filter) {
+      throw new KindgiApiError(
+        notYetWired(
+          "events.query",
+          "no GET /v1/events route on the API \u2014 event-history query surface has not landed"
+        )
+      );
+    }
+  };
+}
+
+// src/resources/flows.ts
+function makeFlowsClient(transport) {
+  return {
+    async define(flow, options) {
+      const result = await transport.request({
+        method: "POST",
+        path: "/v1/flows",
+        body: { ...flow, projectId: options.projectId },
+        ...options.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+      return {
+        flowId: result.flowId,
+        version: result.version
+      };
+    },
+    async validate(_graph) {
+      throw new KindgiApiError(
+        notYetWired(
+          "flows.validate",
+          "no POST /v1/flows/validate route on the API \u2014 validation is inline on define() (server returns 400 validation-failed)"
+        )
+      );
+    },
+    async get(id) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/flows/${encodeURIComponent(id)}`
+      });
+    },
+    async list(filter) {
+      const page = await transport.request({
+        method: "GET",
+        path: "/v1/flows",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.name !== void 0 && { name: filter.name }
+        }
+      });
+      return {
+        items: page.data,
+        ...page.nextCursor !== void 0 && {
+          nextCursor: page.nextCursor
+        }
+      };
+    },
+    async versions(id, filter) {
+      const page = await transport.request({
+        method: "GET",
+        path: `/v1/flows/${encodeURIComponent(id)}/versions`,
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor }
+        }
+      });
+      return {
+        items: page.data,
+        ...page.nextCursor !== void 0 && {
+          nextCursor: page.nextCursor
+        }
+      };
+    },
+    async getVersion(id, version) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/flows/${encodeURIComponent(id)}/versions/${encodeURIComponent(version)}`
+      });
+    },
+    async delete(id, version, options) {
+      await transport.request({
+        method: "POST",
+        path: `/v1/flows/${encodeURIComponent(id)}/versions/${encodeURIComponent(version)}/unregister`,
+        body: {},
+        discardResponse: true,
+        ...options?.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+    },
+    async reinstateVersion(id, version, options) {
+      const wire = await transport.request({
+        method: "POST",
+        path: `/v1/flows/${encodeURIComponent(id)}/versions/${encodeURIComponent(version)}/reinstate`,
+        ...options?.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+      return {
+        flowId: wire.flowId,
+        version: wire.version,
+        wasTombstoned: wire.wasTombstoned
+      };
+    }
+  };
+}
+
+// src/resources/guardrails.ts
+function makeGuardrailsClient(transport) {
+  return {
+    async author(spec, options) {
+      return transport.request({
+        method: "POST",
+        path: "/v1/guardrails",
+        body: { ...spec, projectId: options.projectId },
+        ...options.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async get(id) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/guardrails/${encodeURIComponent(id)}`
+      });
+    },
+    async list(filter) {
+      const page = await transport.request({
+        method: "GET",
+        path: "/v1/guardrails",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.name !== void 0 && { name: filter.name }
+        }
+      });
+      return {
+        items: page.data,
+        ...page.nextCursor !== void 0 && {
+          nextCursor: page.nextCursor
+        }
+      };
+    },
+    async delete(id, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/guardrails/${encodeURIComponent(id)}/unregister`,
+        body: {},
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async versions(_id) {
+      throw new KindgiApiError(
+        notYetWired(
+          "guardrails.versions",
+          "no GET /v1/guardrails/{id}/versions route on the API \u2014 wire treats guardrails as flat metadata registrations, no version history"
+        )
+      );
+    },
+    async builtIns() {
+      throw new KindgiApiError(
+        notYetWired(
+          "guardrails.builtIns",
+          "no GET /v1/guardrails/built-ins route on the API \u2014 built-in catalog is a runtime discovery primitive without an HTTP surface yet"
+        )
+      );
+    },
+    async evaluate(_id, _trace) {
+      throw new KindgiApiError(
+        notYetWired(
+          "guardrails.evaluate",
+          "no POST /v1/guardrails/{id}/evaluate route on the API \u2014 direct evaluation is a runtime primitive; standalone HTTP evaluation has no wire surface yet"
+        )
+      );
+    }
+  };
+}
+
+// src/resources/identity.ts
+function makeIdentityClient(transport) {
+  const seg = (s) => encodeURIComponent(s);
+  return {
+    async whoami() {
+      return transport.request({
+        method: "GET",
+        path: "/v1/identity/whoami"
+      });
+    },
+    users: {
+      async list(filter) {
+        return transport.request({
+          method: "GET",
+          path: "/v1/identity/users",
+          query: {
+            ...filter?.limit !== void 0 && { limit: filter.limit },
+            ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+            ...filter?.query !== void 0 && { query: filter.query }
+          }
+        });
+      },
+      async get(userId) {
+        return transport.request({
+          method: "GET",
+          path: `/v1/identity/users/${seg(userId)}`
+        });
+      },
+      async listSessions(userId) {
+        return transport.request({
+          method: "GET",
+          path: `/v1/identity/users/${seg(userId)}/sessions`
+        });
+      },
+      async revokeSessions(userId, options) {
+        return transport.request({
+          method: "POST",
+          path: `/v1/identity/users/${seg(userId)}/revoke-sessions`,
+          ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+        });
+      }
+    }
+  };
+}
+
+// src/resources/mcp.ts
+function makeMcpClient(transport) {
+  return {
+    endpoints: {
+      async list(filter) {
+        const page = await transport.request({
+          method: "GET",
+          path: "/v1/mcp/endpoints",
+          query: {
+            ...filter?.limit !== void 0 && { limit: filter.limit },
+            ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+            ...filter?.transport !== void 0 && { transport: filter.transport }
+          }
+        });
+        return {
+          items: page.data,
+          ...page.nextCursor !== void 0 && {
+            nextCursor: page.nextCursor
+          }
+        };
+      },
+      async register(input, options) {
+        const { scope, ...endpoint } = input;
+        return transport.request({
+          method: "POST",
+          path: "/v1/mcp/endpoints",
+          // The scope travels as the `scopeKind` + `scopeId` pair.
+          body: { ...endpoint, ...scopeToQuery(scope) },
+          ...options?.idempotencyKey !== void 0 && {
+            idempotencyKey: options.idempotencyKey
+          }
+        });
+      },
+      async get(endpointId) {
+        return transport.request({
+          method: "GET",
+          path: `/v1/mcp/endpoints/${encodeURIComponent(endpointId)}`
+        });
+      },
+      async unregister(endpointId, options) {
+        await transport.request({
+          method: "POST",
+          path: `/v1/mcp/endpoints/${encodeURIComponent(endpointId)}/unregister`,
+          body: {},
+          discardResponse: true,
+          ...options?.idempotencyKey !== void 0 && {
+            idempotencyKey: options.idempotencyKey
+          }
+        });
+      },
+      resources: {
+        async list(endpointId) {
+          return transport.request({
+            method: "GET",
+            path: `/v1/mcp/endpoints/${encodeURIComponent(endpointId)}/resources`
+          });
+        },
+        async read(endpointId, uri) {
+          return transport.request({
+            method: "GET",
+            path: `/v1/mcp/endpoints/${encodeURIComponent(endpointId)}/resources/${encodeURIComponent(uri)}`
+          });
+        }
+      },
+      prompts: {
+        async list(endpointId) {
+          return transport.request({
+            method: "GET",
+            path: `/v1/mcp/endpoints/${encodeURIComponent(endpointId)}/prompts`
+          });
+        },
+        async get(endpointId, name, args, options) {
+          return transport.request({
+            method: "POST",
+            path: `/v1/mcp/endpoints/${encodeURIComponent(endpointId)}/prompts/${encodeURIComponent(name)}`,
+            body: args ?? {},
+            ...options?.idempotencyKey !== void 0 && {
+              idempotencyKey: options.idempotencyKey
+            }
+          });
+        }
+      }
+    },
+    async serverInfo() {
+      throw new KindgiApiError(
+        notYetWired(
+          "mcp.serverInfo",
+          "no GET /v1/mcp/server-info route on the API \u2014 inbound MCP-server surface (exposing the OS via MCP) not routed yet"
+        )
+      );
+    },
+    async tools() {
+      throw new KindgiApiError(
+        notYetWired(
+          "mcp.tools",
+          "no GET /v1/mcp/tools route on the API \u2014 use client.tools.list() (wire Tool IS the MCP manifest)"
+        )
+      );
+    },
+    async agents() {
+      throw new KindgiApiError(
+        notYetWired(
+          "mcp.agents",
+          "no GET /v1/mcp/agents route on the API \u2014 inbound-server exposure of agents not routed yet"
+        )
+      );
+    },
+    async invokeTool(_name, _input) {
+      throw new KindgiApiError(
+        notYetWired(
+          "mcp.invokeTool",
+          "no POST /v1/mcp/invoke-tool route on the API \u2014 MCP-transport tool invocation not surfaced yet"
+        )
+      );
+    },
+    async invokeAgent(_agentId, _input) {
+      throw new KindgiApiError(
+        notYetWired(
+          "mcp.invokeAgent",
+          "no POST /v1/mcp/invoke-agent route on the API \u2014 use client.runs.start({ agent }) for agent invocation"
+        )
+      );
+    }
+  };
+}
+
+// src/resources/memory.ts
+function makeMemoryClient(transport) {
+  return {
+    facts: {
+      async write(input, options) {
+        return transport.request({
+          method: "POST",
+          path: "/v1/memory/facts",
+          body: input,
+          ...options?.idempotencyKey !== void 0 && {
+            idempotencyKey: options.idempotencyKey
+          }
+        });
+      },
+      async read(id) {
+        return transport.request({
+          method: "GET",
+          path: `/v1/memory/facts/${encodeURIComponent(id)}`
+        });
+      },
+      async list(filter) {
+        const page = await transport.request({
+          method: "GET",
+          path: "/v1/memory/facts",
+          query: {
+            ...filter?.limit !== void 0 && { limit: filter.limit },
+            ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+            ...filter?.type !== void 0 && { type: filter.type },
+            ...filter?.scope !== void 0 && { scope: JSON.stringify(filter.scope) }
+          }
+        });
+        return {
+          items: page.data,
+          ...page.nextCursor !== void 0 && {
+            nextCursor: page.nextCursor
+          }
+        };
+      },
+      async delete(id, options) {
+        return transport.request({
+          method: "POST",
+          path: `/v1/memory/facts/${encodeURIComponent(id)}/supersede`,
+          body: {},
+          ...options?.idempotencyKey !== void 0 && {
+            idempotencyKey: options.idempotencyKey
+          }
+        });
+      }
+    },
+    logs: {
+      async append(_input) {
+        throw new KindgiApiError(
+          notYetWired(
+            "memory.logs.append",
+            "no POST /v1/memory/logs route on the API \u2014 append-only log HTTP surface has not landed (runtime primitive exists in-process)"
+          )
+        );
+      },
+      async list(_filter) {
+        throw new KindgiApiError(
+          notYetWired(
+            "memory.logs.list",
+            "no GET /v1/memory/logs route on the API \u2014 log HTTP surface has not landed"
+          )
+        );
+      },
+      async verify(_entries) {
+        throw new KindgiApiError(
+          notYetWired(
+            "memory.logs.verify",
+            "no POST /v1/memory/logs/verify route on the API \u2014 log HTTP surface has not landed; verification is client-side callable in principle but requires logs.list first"
+          )
+        );
+      }
+    },
+    async search(input) {
+      const envelope = await transport.request({
+        method: "POST",
+        path: "/v1/memory/retrieve",
+        body: input
+      });
+      return envelope.results;
+    }
+  };
+}
+
+// src/resources/observations.ts
+function makeObservationsClient(transport) {
+  return {
+    async recordRun(_runId) {
+      throw new KindgiApiError(
+        notYetWired(
+          "observations.recordRun",
+          "no POST /v1/observations route on the API \u2014 supervisor runtime records observations server-internally"
+        )
+      );
+    },
+    async query(filter) {
+      const page = await transport.request({
+        method: "GET",
+        path: "/v1/observations",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.status !== void 0 && { status: filter.status },
+          ...filter?.supervisorId !== void 0 && {
+            supervisorId: filter.supervisorId
+          },
+          ...filter?.agentId !== void 0 && { agentId: filter.agentId },
+          ...filter?.agentVersion !== void 0 && { agentVersion: filter.agentVersion },
+          ...filter?.conversationId !== void 0 && {
+            conversationId: filter.conversationId
+          },
+          ...filter?.since !== void 0 && { since: filter.since },
+          ...filter?.until !== void 0 && { until: filter.until }
+        }
+      });
+      return {
+        items: page.data,
+        ...page.nextCursor !== void 0 && { nextCursor: page.nextCursor }
+      };
+    },
+    async patterns(_input) {
+      throw new KindgiApiError(
+        notYetWired(
+          "observations.patterns",
+          "no /v1/observations/patterns route on the API \u2014 aggregation surface unrouted"
+        )
+      );
+    }
+  };
+}
+
+// src/resources/orgs.ts
+function makeOrgsClient(transport) {
+  const seg = (s) => encodeURIComponent(s);
+  return {
+    async create(input, options) {
+      return transport.request({
+        method: "POST",
+        path: "/v1/orgs",
+        body: input,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async list(filter) {
+      return transport.request({
+        method: "GET",
+        path: "/v1/orgs",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor }
+        }
+      });
+    },
+    async get(orgId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/orgs/${seg(orgId)}`
+      });
+    },
+    async update(orgId, input, options) {
+      return transport.request({
+        method: "PATCH",
+        path: `/v1/orgs/${seg(orgId)}`,
+        body: input,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async delete(orgId) {
+      return transport.request({
+        method: "DELETE",
+        path: `/v1/orgs/${seg(orgId)}`,
+        discardResponse: true
+      });
+    }
+  };
+}
+
+// src/resources/packs.ts
+var REASON_NO_PACK_API = "the API has no pack routes or wire schemas (Pack / InstalledPack / PackInstallInput) yet";
+function makePacksClient(_transport) {
+  return {
+    async install(_input) {
+      throw new KindgiApiError(notYetWired("packs.install", REASON_NO_PACK_API));
+    },
+    async installed(_filter) {
+      throw new KindgiApiError(notYetWired("packs.installed", REASON_NO_PACK_API));
+    },
+    async get(_id) {
+      throw new KindgiApiError(notYetWired("packs.get", REASON_NO_PACK_API));
+    },
+    async versions(_id) {
+      throw new KindgiApiError(notYetWired("packs.versions", REASON_NO_PACK_API));
+    },
+    async configure(_id, _config) {
+      throw new KindgiApiError(notYetWired("packs.configure", REASON_NO_PACK_API));
+    },
+    async disable(_id) {
+      throw new KindgiApiError(notYetWired("packs.disable", REASON_NO_PACK_API));
+    },
+    async enable(_id) {
+      throw new KindgiApiError(notYetWired("packs.enable", REASON_NO_PACK_API));
+    },
+    async upgrade(_id, _newVersion) {
+      throw new KindgiApiError(notYetWired("packs.upgrade", REASON_NO_PACK_API));
+    },
+    async uninstall(_id) {
+      throw new KindgiApiError(notYetWired("packs.uninstall", REASON_NO_PACK_API));
+    },
+    registry: {
+      async browse(_filter) {
+        throw new KindgiApiError(
+          notYetWired(
+            "packs.registry.browse",
+            "v2 pack registry (public + private catalog federation) builds on the pack authoring API \u2014 not implemented yet"
+          )
+        );
+      },
+      async configured() {
+        throw new KindgiApiError(
+          notYetWired(
+            "packs.registry.configured",
+            "v2 pack registry (public + private catalog federation) builds on the pack authoring API \u2014 not implemented yet"
+          )
+        );
+      }
+    }
+  };
+}
+
+// src/resources/policies.ts
+function makePoliciesClient(transport) {
+  return {
+    async author(spec, options) {
+      const result = await transport.request({
+        method: "POST",
+        path: "/v1/policies",
+        body: {
+          id: spec.id,
+          version: spec.version,
+          kind: spec.kind,
+          ...spec.description !== void 0 && { description: spec.description },
+          spec: spec.spec
+        },
+        ...options?.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+      return {
+        policyId: result.policyId,
+        version: result.version
+      };
+    },
+    async get(id) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/policies/${encodeURIComponent(id)}`
+      });
+    },
+    async list(filter) {
+      const page = await transport.request({
+        method: "GET",
+        path: "/v1/policies",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.kind !== void 0 && { kind: filter.kind },
+          ...filter?.name !== void 0 && { name: filter.name }
+        }
+      });
+      return {
+        items: page.data,
+        ...page.nextCursor !== void 0 && {
+          nextCursor: page.nextCursor
+        }
+      };
+    },
+    async versions(id, filter) {
+      const page = await transport.request({
+        method: "GET",
+        path: `/v1/policies/${encodeURIComponent(id)}/versions`,
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.includeTombstoned === true && { includeTombstoned: "true" }
+        }
+      });
+      return {
+        items: page.data,
+        ...page.nextCursor !== void 0 && {
+          nextCursor: page.nextCursor
+        }
+      };
+    },
+    async getVersion(id, version) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/policies/${encodeURIComponent(id)}/versions/${encodeURIComponent(version)}`
+      });
+    },
+    async unregister(id, version, options) {
+      await transport.request({
+        method: "POST",
+        path: `/v1/policies/${encodeURIComponent(id)}/versions/${encodeURIComponent(version)}/unregister`,
+        body: {},
+        discardResponse: true,
+        ...options?.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+    },
+    async reinstateVersion(id, version, options) {
+      const wire = await transport.request({
+        method: "POST",
+        path: `/v1/policies/${encodeURIComponent(id)}/versions/${encodeURIComponent(version)}/reinstate`,
+        ...options?.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+      return {
+        policyId: wire.policyId,
+        version: wire.version,
+        wasTombstoned: wire.wasTombstoned
+      };
+    },
+    async activate(_id) {
+      throw new KindgiApiError(
+        notYetWired(
+          "policies.activate",
+          "no POST /v1/policies/{policyId}/activate route on the API \u2014 the wire has no draft/active lifecycle; policies are active at publish"
+        )
+      );
+    },
+    async evaluate(_id, _input) {
+      throw new KindgiApiError(
+        notYetWired(
+          "policies.evaluate",
+          "no POST /v1/policies/{policyId}/evaluate route on the API \u2014 evaluation is a runtime primitive without an SDK surface yet"
+        )
+      );
+    }
+  };
+}
+
+// src/resources/projects.ts
+function makeProjectsClient(transport) {
+  const seg = (s) => encodeURIComponent(s);
+  return {
+    async create(input, options) {
+      return transport.request({
+        method: "POST",
+        path: "/v1/projects",
+        body: input,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async list(filter) {
+      return transport.request({
+        method: "GET",
+        path: "/v1/projects",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor }
+        }
+      });
+    },
+    async getDefault() {
+      return transport.request({
+        method: "GET",
+        path: "/v1/projects/default"
+      });
+    },
+    async get(projectId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/projects/${seg(projectId)}`
+      });
+    },
+    async update(projectId, input, options) {
+      return transport.request({
+        method: "PATCH",
+        path: `/v1/projects/${seg(projectId)}`,
+        body: input,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async delete(projectId) {
+      return transport.request({
+        method: "DELETE",
+        path: `/v1/projects/${seg(projectId)}`,
+        discardResponse: true
+      });
+    },
+    memberships: {
+      async list(projectId, filter) {
+        return transport.request({
+          method: "GET",
+          path: `/v1/projects/${seg(projectId)}/memberships`,
+          query: {
+            ...filter?.limit !== void 0 && { limit: filter.limit },
+            ...filter?.cursor !== void 0 && { cursor: filter.cursor }
+          }
+        });
+      },
+      async add(projectId, input, options) {
+        return transport.request({
+          method: "POST",
+          path: `/v1/projects/${seg(projectId)}/memberships`,
+          body: input,
+          ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+        });
+      },
+      async updateRole(projectId, userId, role, options) {
+        return transport.request({
+          method: "PATCH",
+          path: `/v1/projects/${seg(projectId)}/memberships/${seg(userId)}`,
+          body: { role },
+          discardResponse: true,
+          ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+        });
+      },
+      async remove(projectId, userId, options) {
+        return transport.request({
+          method: "DELETE",
+          path: `/v1/projects/${seg(projectId)}/memberships/${seg(userId)}`,
+          discardResponse: true,
+          ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+        });
+      }
+    }
+  };
+}
+
+// src/resources/provenance.ts
+function makeProvenanceClient(transport) {
+  return {
+    async get(runId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/provenance/${encodeURIComponent(runId)}`
+      });
+    },
+    async query(filter) {
+      const page = await transport.request({
+        method: "GET",
+        path: "/v1/provenance",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.runId !== void 0 && { runId: filter.runId },
+          ...filter?.agentId !== void 0 && {
+            agentId: filter.agentId
+          },
+          ...filter?.createdAfter !== void 0 && {
+            createdAfter: filter.createdAfter
+          }
+        }
+      });
+      return {
+        items: page.data,
+        ...page.nextCursor !== void 0 && { nextCursor: page.nextCursor }
+      };
+    },
+    async export(input) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/provenance/${encodeURIComponent(input.runId)}/export`,
+        body: {
+          signingKeyId: input.signingKeyId,
+          ...input.includeMessages !== void 0 && { includeMessages: input.includeMessages }
+        },
+        ...input.idempotencyKey !== void 0 && { idempotencyKey: input.idempotencyKey }
+      });
+    },
+    async verify(_exported, _publicKey) {
+      throw new KindgiApiError(
+        notYetWired(
+          "provenance.verify",
+          "client-side ed25519 verification requires the crypto module subpackage to be reachable from the SDK"
+        )
+      );
+    }
+  };
+}
+
+// src/resources/providers.ts
+function makeProvidersClient(transport) {
+  const seg = (s) => encodeURIComponent(s);
+  return {
+    async register(input, options) {
+      return transport.request({
+        method: "POST",
+        path: "/v1/providers",
+        body: input,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async list(filter) {
+      return transport.request({
+        method: "GET",
+        path: "/v1/providers",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.feature !== void 0 && { feature: filter.feature }
+        }
+      });
+    },
+    async get(providerId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/providers/${seg(providerId)}`
+      });
+    },
+    async capabilities(providerId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/providers/${seg(providerId)}/capabilities`
+      });
+    },
+    async unregister(providerId, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/providers/${seg(providerId)}/unregister`,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    }
+  };
+}
+
+// src/run-follow.ts
+var MAX_REFRESHES_IN_A_ROW = 3;
+var TERMINAL_KINDS = /* @__PURE__ */ new Set([
+  "run.completed",
+  "run.failed",
+  "run.cancelled"
+]);
+async function* followRun(options) {
+  const state = { lastEventId: void 0, refreshesInARow: 0 };
+  while (options.signal?.aborted !== true) {
+    const outcome = yield* followOnce(options, state);
+    if (outcome === "terminal" || outcome === "aborted") return;
+    if (outcome === "empty") await sleep(options.initialBackoffMs ?? 500, options.signal);
+  }
+}
+async function* followOnce(options, state) {
+  let received = 0;
+  try {
+    for await (const event of readSse(connectionOptions(options, state.lastEventId))) {
+      received += 1;
+      state.refreshesInARow = 0;
+      if (event.id !== void 0) state.lastEventId = event.id;
+      yield event.data;
+      if (TERMINAL_KINDS.has(event.data.kind)) return "terminal";
+    }
+  } catch (error) {
+    if (options.signal?.aborted === true) return "aborted";
+    if (!await refreshAfter(error, options, state.refreshesInARow)) throw error;
+    state.refreshesInARow += 1;
+    return "refreshed";
+  }
+  return received === 0 ? "empty" : "closed";
+}
+function connectionOptions(options, lastEventId) {
+  return {
+    url: options.url,
+    headers: options.headers,
+    ...lastEventId !== void 0 && { lastEventId },
+    ...options.fetchImpl !== void 0 && { fetchImpl: options.fetchImpl },
+    ...options.signal !== void 0 && { signal: options.signal },
+    ...options.initialBackoffMs !== void 0 && { initialBackoffMs: options.initialBackoffMs },
+    ...options.maxBackoffMs !== void 0 && { maxBackoffMs: options.maxBackoffMs },
+    // Client errors (401 expired token, 403, 404) don't heal by retrying.
+    shouldRetry: (attempt, error) => !(error instanceof SseHttpError && error.status >= 400 && error.status < 500) && attempt < 10
+  };
+}
+async function refreshAfter(error, options, refreshesInARow) {
+  if (!(error instanceof SseHttpError) || error.status !== 401) return false;
+  if (options.onUnauthorized === void 0 || refreshesInARow >= MAX_REFRESHES_IN_A_ROW) {
+    return false;
+  }
+  return options.onUnauthorized();
+}
+function subscribeToRun(options) {
+  let token = options.accessToken;
+  const refresh = options.refreshAccessToken;
+  return followRun({
+    url: `${options.apiUrl.replace(/\/+$/, "")}/v1/runs/${encodeURIComponent(options.runId)}/progress/stream`,
+    headers: () => ({ Authorization: `Bearer ${token}` }),
+    ...refresh !== void 0 && {
+      onUnauthorized: async () => {
+        token = await refresh();
+        return true;
+      }
+    },
+    ...options.fetch !== void 0 && { fetchImpl: options.fetch },
+    ...options.signal !== void 0 && { signal: options.signal }
+  });
+}
+
+// src/resources/runs.ts
+function makeRunsClient(transport) {
+  return {
+    async start(input) {
+      const body = "agent" in input ? {
+        agent: input.agent,
+        ...input.agentVersion !== void 0 && { agentVersion: input.agentVersion },
+        ...input.projectId !== void 0 && { projectId: input.projectId },
+        input: input.input,
+        ...input.options !== void 0 && { options: input.options }
+      } : {
+        flow: input.flow,
+        ...input.flowVersion !== void 0 && { flowVersion: input.flowVersion },
+        ...input.projectId !== void 0 && { projectId: input.projectId },
+        input: input.input,
+        ...input.options !== void 0 && { options: input.options }
+      };
+      return transport.request({
+        method: "POST",
+        path: "/v1/runs",
+        body,
+        ...input.idempotencyKey !== void 0 && {
+          idempotencyKey: input.idempotencyKey
+        }
+      });
+    },
+    async dryRun(_input) {
+      throw new KindgiApiError(
+        notYetWired(
+          "runs.dryRun",
+          "no dedicated dry-run route on the API \u2014 use runs.start({ ..., options: { dryRun: true } }); the design-drafted DryRunResult (planned nodes / cost estimate) is a distinct preview primitive that has no wire route yet"
+        )
+      );
+    },
+    async progress(runId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/runs/${encodeURIComponent(runId)}/progress`
+      });
+    },
+    streamProgress(runId, options) {
+      return followRun({
+        url: `${transport.apiUrl}/v1/runs/${encodeURIComponent(runId)}/progress/stream`,
+        headers: () => transport.authHeaders(),
+        fetchImpl: transport.fetchImpl,
+        ...options?.signal !== void 0 && { signal: options.signal },
+        ...options?.initialBackoffMs !== void 0 && {
+          initialBackoffMs: options.initialBackoffMs
+        },
+        ...options?.maxBackoffMs !== void 0 && {
+          maxBackoffMs: options.maxBackoffMs
+        }
+      });
+    },
+    stream(runId, options) {
+      return followRun({
+        url: `${transport.apiUrl}/v1/runs/${encodeURIComponent(runId)}/stream`,
+        headers: () => transport.authHeaders(),
+        fetchImpl: transport.fetchImpl,
+        ...options?.signal !== void 0 && { signal: options.signal },
+        ...options?.initialBackoffMs !== void 0 && {
+          initialBackoffMs: options.initialBackoffMs
+        },
+        ...options?.maxBackoffMs !== void 0 && {
+          maxBackoffMs: options.maxBackoffMs
+        }
+      });
+    },
+    async get(runId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/runs/${encodeURIComponent(runId)}`
+      });
+    },
+    async resume(input) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/runs/${encodeURIComponent(input.runId)}/resume`,
+        body: {
+          waitpointId: input.waitpointId,
+          ...input.value !== void 0 && { value: input.value }
+        },
+        ...input.idempotencyKey !== void 0 && {
+          idempotencyKey: input.idempotencyKey
+        }
+      });
+    },
+    async cancel(runId, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/runs/${encodeURIComponent(runId)}/cancel`,
+        body: {},
+        ...options?.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+    },
+    async list(filter) {
+      return transport.request({
+        method: "GET",
+        path: "/v1/runs",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.parentRunId !== void 0 && {
+            parentRunId: filter.parentRunId
+          },
+          ...filter?.topLevel !== void 0 && { topLevel: String(filter.topLevel) },
+          ...filter?.includeOutput === true && { include: "output" }
+        }
+      });
+    },
+    async journal(runId, filter) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/runs/${encodeURIComponent(runId)}/journal`,
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.since !== void 0 && { since: filter.since }
+        }
+      });
+    }
+  };
+}
+
+// src/resources/schedules.ts
+function makeSchedulesClient(transport) {
+  return {
+    async register(input, options) {
+      return transport.request({
+        method: "POST",
+        path: "/v1/schedules",
+        body: input,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async list(filter) {
+      return transport.request({
+        method: "GET",
+        path: "/v1/schedules",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.status !== void 0 && { status: filter.status }
+        }
+      });
+    },
+    async get(triggerId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/schedules/${encodeURIComponent(triggerId)}`
+      });
+    },
+    async update(triggerId, input, options) {
+      return transport.request({
+        method: "PATCH",
+        path: `/v1/schedules/${encodeURIComponent(triggerId)}`,
+        body: input,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async pause(triggerId, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/schedules/${encodeURIComponent(triggerId)}/pause`,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async resume(triggerId, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/schedules/${encodeURIComponent(triggerId)}/resume`,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async unregister(triggerId, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/schedules/${encodeURIComponent(triggerId)}/unregister`,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    }
+  };
+}
+
+// src/resources/secrets.ts
+var DEFAULT_INITIAL_DELAY_MS = 1e3;
+var DEFAULT_MAX_DELAY_MS = 3e4;
+var DEFAULT_CEILING_MS = 15 * 60 * 1e3;
+var defaultSleep = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+async function pollForRotationTerminal(transport, input, rotationId) {
+  const overrides = input.pollingOverrides;
+  const initialDelay = overrides?.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;
+  const maxDelay = overrides?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+  const ceiling = overrides?.ceilingMs ?? DEFAULT_CEILING_MS;
+  const sleep2 = overrides?.sleep ?? defaultSleep;
+  const q = scopeToQuery(input.scope);
+  const startedAt = Date.now();
+  let nextDelay = initialDelay;
+  const query = {
+    envName: input.envName,
+    scopeKind: q.scopeKind,
+    ...q.scopeId !== void 0 && { scopeId: q.scopeId }
+  };
+  const statusPath = `/v1/secrets/${encodeURIComponent(input.name)}/rotations/${encodeURIComponent(rotationId)}`;
+  for (; ; ) {
+    await sleep2(nextDelay);
+    const elapsed = Date.now() - startedAt;
+    if (elapsed >= ceiling) {
+      const statusUrl = `${transport.apiUrl}${statusPath}`;
+      return { kind: "timeout", rotationId, statusUrl };
+    }
+    const status = await transport.request({
+      method: "GET",
+      path: statusPath,
+      query
+    });
+    if (status.status === "succeeded") {
+      if (status.newVersionId === void 0 || status.oldVersionId === void 0) {
+        return {
+          kind: "failed",
+          error: "succeeded status returned without newVersionId/oldVersionId"
+        };
+      }
+      return {
+        kind: "ok",
+        newVersionId: status.newVersionId,
+        oldVersionId: status.oldVersionId
+      };
+    }
+    if (status.status === "failed") {
+      return { kind: "failed", error: status.error ?? "rotation failed" };
+    }
+    if (status.status === "cancelled") {
+      return { kind: "cancelled" };
+    }
+    nextDelay = Math.min(nextDelay * 2, maxDelay);
+  }
+}
+function makeSecretsClient(transport) {
+  return {
+    async list(input) {
+      const q = scopeToQuery(input.scope);
+      const page = await transport.request({
+        method: "GET",
+        path: "/v1/secrets",
+        query: {
+          envName: input.envName,
+          scopeKind: q.scopeKind,
+          ...q.scopeId !== void 0 && { scopeId: q.scopeId },
+          ...input.cursor !== void 0 && { cursor: input.cursor },
+          ...input.namePrefix !== void 0 && { namePrefix: input.namePrefix },
+          ...input.includeRevoked === true && { includeRevoked: true },
+          ...input.limit !== void 0 && { limit: input.limit }
+        }
+      });
+      return {
+        data: page.data,
+        ...page.nextCursor !== void 0 && {
+          nextCursor: page.nextCursor
+        }
+      };
+    },
+    async get(input) {
+      const q = scopeToQuery(input.scope);
+      try {
+        return await transport.request({
+          method: "GET",
+          path: `/v1/secrets/${encodeURIComponent(input.name)}`,
+          query: {
+            envName: input.envName,
+            scopeKind: q.scopeKind,
+            ...q.scopeId !== void 0 && { scopeId: q.scopeId }
+          }
+        });
+      } catch (err) {
+        if (isKindOfNotFound(err, "secret-not-found", "secret")) return null;
+        throw err;
+      }
+    },
+    async getVersion(input) {
+      const q = scopeToQuery(input.scope);
+      try {
+        return await transport.request({
+          method: "GET",
+          path: `/v1/secrets/${encodeURIComponent(input.name)}/versions/${input.versionId}`,
+          query: {
+            envName: input.envName,
+            scopeKind: q.scopeKind,
+            ...q.scopeId !== void 0 && { scopeId: q.scopeId }
+          }
+        });
+      } catch (err) {
+        if (isKindOfNotFound(err, "secret-version-not-found", "secret-version")) return null;
+        throw err;
+      }
+    },
+    async listVersions(input) {
+      const q = scopeToQuery(input.scope);
+      const page = await transport.request({
+        method: "GET",
+        path: `/v1/secrets/${encodeURIComponent(input.name)}/versions`,
+        query: {
+          envName: input.envName,
+          scopeKind: q.scopeKind,
+          ...q.scopeId !== void 0 && { scopeId: q.scopeId },
+          ...input.cursor !== void 0 && { cursor: input.cursor },
+          ...input.limit !== void 0 && { limit: input.limit }
+        }
+      });
+      return {
+        data: page.data,
+        ...page.nextCursor !== void 0 && {
+          nextCursor: page.nextCursor
+        }
+      };
+    },
+    async set(input) {
+      try {
+        const ok = await transport.request({
+          method: "POST",
+          path: "/v1/secrets",
+          body: {
+            scope: scopeForBody(input.scope),
+            envName: input.envName,
+            name: input.name,
+            value: input.value,
+            writeMode: input.writeMode,
+            ...input.ifVersion !== void 0 && { ifVersion: input.ifVersion },
+            ...input.rotationDueAt !== void 0 && { rotationDueAt: input.rotationDueAt },
+            ...input.tags !== void 0 && { tags: input.tags }
+          },
+          ...input.idempotencyKey !== void 0 && {
+            idempotencyKey: input.idempotencyKey
+          }
+        });
+        return { kind: "ok", record: ok.record, versionId: ok.versionId };
+      } catch (err) {
+        const conflict = tryReadVersionConflict(err);
+        if (conflict !== null) return conflict;
+        throw err;
+      }
+    },
+    async rotate(input) {
+      const q = scopeToQuery(input.scope);
+      const response = await transport.request({
+        method: "POST",
+        path: `/v1/secrets/${encodeURIComponent(input.name)}/rotate`,
+        query: {
+          envName: input.envName,
+          scopeKind: q.scopeKind,
+          ...q.scopeId !== void 0 && { scopeId: q.scopeId }
+        },
+        body: {
+          scope: scopeForBody(input.scope),
+          envName: input.envName,
+          ...input.newValue !== void 0 && { newValue: input.newValue },
+          ...input.revokeOldAfterMs !== void 0 && {
+            revokeOldAfterMs: input.revokeOldAfterMs
+          }
+        },
+        ...input.idempotencyKey !== void 0 && {
+          idempotencyKey: input.idempotencyKey
+        }
+      });
+      const mode = input.mode ?? "wait-for-complete";
+      if (mode === "raw") {
+        return { kind: "raw", response };
+      }
+      if (response.kind === "sync") {
+        return {
+          kind: "ok",
+          newVersionId: response.newVersionId,
+          oldVersionId: response.oldVersionId,
+          ...response.oldVersionRevokedAt !== void 0 && {
+            oldVersionRevokedAt: response.oldVersionRevokedAt
+          }
+        };
+      }
+      return pollForRotationTerminal(transport, input, response.rotationId);
+    },
+    async revoke(input) {
+      const q = scopeToQuery(input.scope);
+      return transport.request({
+        method: "DELETE",
+        path: `/v1/secrets/${encodeURIComponent(input.name)}`,
+        query: {
+          envName: input.envName,
+          scopeKind: q.scopeKind,
+          ...q.scopeId !== void 0 && { scopeId: q.scopeId },
+          ...input.hard === true && { hard: true },
+          ...input.reason !== void 0 && { reason: input.reason }
+        }
+      });
+    },
+    rotations: {
+      async get(input) {
+        const q = scopeToQuery(input.scope);
+        return transport.request({
+          method: "GET",
+          path: `/v1/secrets/${encodeURIComponent(input.name)}/rotations/${encodeURIComponent(input.rotationId)}`,
+          query: {
+            envName: input.envName,
+            scopeKind: q.scopeKind,
+            ...q.scopeId !== void 0 && { scopeId: q.scopeId }
+          }
+        });
+      },
+      events(input, options) {
+        const q = scopeToQuery(input.scope);
+        const params = new URLSearchParams();
+        params.set("envName", input.envName);
+        params.set("scopeKind", q.scopeKind);
+        if (q.scopeId !== void 0) params.set("scopeId", q.scopeId);
+        const url = `${transport.apiUrl}/v1/secrets/${encodeURIComponent(input.name)}/rotations/${encodeURIComponent(input.rotationId)}/events?${params.toString()}`;
+        const source = readSse({
+          url,
+          headers: transport.authHeaders(),
+          fetchImpl: transport.fetchImpl,
+          ...options?.signal !== void 0 && { signal: options.signal },
+          ...options?.initialBackoffMs !== void 0 && {
+            initialBackoffMs: options.initialBackoffMs
+          },
+          ...options?.maxBackoffMs !== void 0 && {
+            maxBackoffMs: options.maxBackoffMs
+          }
+        });
+        return unwrapSseData(source);
+      }
+    }
+  };
+}
+function isKindOfNotFound(err, wireCode, resourceKind) {
+  if (err === null || typeof err !== "object") return false;
+  const asAny = err;
+  const inner = asAny.error;
+  if (inner === void 0) return false;
+  const code = inner.code;
+  const serverCode = inner.serverCode;
+  if (code === wireCode) return true;
+  if (code === "server" && serverCode === wireCode) return true;
+  if (code === "not-found" && typeof inner.resource === "object" && inner.resource !== null && inner.resource.kind === resourceKind) {
+    return true;
+  }
+  return false;
+}
+function tryReadVersionConflict(err) {
+  if (err === null || typeof err !== "object") return null;
+  const asAny = err;
+  const inner = asAny.error;
+  if (inner === void 0) return null;
+  const isConflict = inner.code === "secret-write-conflict" || inner.code === "conflict" || inner.serverCode === "secret-write-conflict";
+  if (!isConflict) return null;
+  const fromFields = inner.fields?.currentVersion;
+  const current = typeof fromFields === "number" ? fromFields : inner.currentVersion;
+  if (typeof current !== "number") return null;
+  return { kind: "version-conflict", currentVersion: current };
+}
+
+// src/resources/signing-keys.ts
+function makeSigningKeysClient(transport) {
+  return {
+    async trust(input, options) {
+      return transport.request({
+        method: "POST",
+        path: "/v1/signing-keys",
+        body: input,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async list(filter) {
+      return transport.request({
+        method: "GET",
+        path: "/v1/signing-keys",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.includeRevoked === true && { includeRevoked: "true" },
+          ...filter?.label !== void 0 && { label: filter.label }
+        }
+      });
+    },
+    async get(keyId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/signing-keys/${encodeURIComponent(keyId)}`
+      });
+    },
+    async revoke(keyId, input, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/signing-keys/${encodeURIComponent(keyId)}/revoke`,
+        body: input ?? {},
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    }
+  };
+}
+
+// src/resources/supervisor.ts
+var REASON_NO_SUPERVISOR_CRUD = "no /v1/supervisors CRUD routes on the API \u2014 supervisor persistence is caller-plugged via SupervisorBinding at deployment boot (framework does NOT own supervisor storage; analogous to the identity-directory pattern for users)";
+function makeSupervisorClient(transport) {
+  const supervisorHeader = (supervisorId) => ({
+    "X-Supervisor-Id": supervisorId
+  });
+  return {
+    async define(_spec) {
+      throw new KindgiApiError(notYetWired("supervisor.define", REASON_NO_SUPERVISOR_CRUD));
+    },
+    async get(_id) {
+      throw new KindgiApiError(notYetWired("supervisor.get", REASON_NO_SUPERVISOR_CRUD));
+    },
+    async list(_filter) {
+      throw new KindgiApiError(notYetWired("supervisor.list", REASON_NO_SUPERVISOR_CRUD));
+    },
+    async versions(_id) {
+      throw new KindgiApiError(notYetWired("supervisor.versions", REASON_NO_SUPERVISOR_CRUD));
+    },
+    async delete(_id) {
+      throw new KindgiApiError(notYetWired("supervisor.delete", REASON_NO_SUPERVISOR_CRUD));
+    },
+    proposals: {
+      async draft(input) {
+        return transport.request({
+          method: "POST",
+          path: "/v1/proposals",
+          headers: supervisorHeader(input.supervisorId),
+          body: {
+            agentId: input.agentId,
+            agentVersion: input.agentVersion,
+            tier: input.tier,
+            change: input.change,
+            patternRefs: input.patternRefs,
+            hypothesis: input.hypothesis,
+            proposerRuleId: input.proposerRuleId
+          },
+          ...input.idempotencyKey !== void 0 && { idempotencyKey: input.idempotencyKey }
+        });
+      },
+      async list(input) {
+        const page = await transport.request({
+          method: "GET",
+          path: "/v1/proposals",
+          headers: supervisorHeader(input.supervisorId),
+          query: {
+            ...input.limit !== void 0 && { limit: input.limit },
+            ...input.cursor !== void 0 && { cursor: input.cursor },
+            ...input.status !== void 0 && { status: input.status },
+            ...input.agentId !== void 0 && { agentId: input.agentId },
+            ...input.tier !== void 0 && { tier: input.tier }
+          }
+        });
+        return {
+          items: page.data,
+          ...page.nextCursor !== void 0 && {
+            nextCursor: page.nextCursor
+          }
+        };
+      },
+      async get(supervisorId, id) {
+        return transport.request({
+          method: "GET",
+          path: `/v1/proposals/${encodeURIComponent(id)}`,
+          headers: supervisorHeader(supervisorId)
+        });
+      },
+      async dryRun(supervisorId, id, input) {
+        return transport.request({
+          method: "POST",
+          path: `/v1/proposals/${encodeURIComponent(id)}/dry-run`,
+          headers: supervisorHeader(supervisorId),
+          body: {
+            datasetId: input.datasetId,
+            datasetVersion: input.datasetVersion,
+            criterion: input.criterion
+          },
+          ...input.idempotencyKey !== void 0 && { idempotencyKey: input.idempotencyKey }
+        });
+      },
+      async submitForReview(supervisorId, id, input) {
+        const body = {};
+        if (input?.requiredRole !== void 0) body.requiredRole = input.requiredRole;
+        if (input?.expiresAt !== void 0) body.expiresAt = input.expiresAt;
+        return transport.request({
+          method: "POST",
+          path: `/v1/proposals/${encodeURIComponent(id)}/submit-review`,
+          headers: supervisorHeader(supervisorId),
+          body,
+          ...input?.idempotencyKey !== void 0 && { idempotencyKey: input.idempotencyKey }
+        });
+      },
+      async reflectReview(_supervisorId, _id, _input) {
+        throw new KindgiApiError(
+          notYetWired(
+            "supervisor.proposals.reflectReview",
+            "no POST /v1/proposals/{id}/reflect-review route on the API \u2014 review reflection is atomic with POST /v1/approvals/{id}/complete (wire detects the linked proposal + updates status alongside the decision)"
+          )
+        );
+      },
+      async apply(supervisorId, id, input) {
+        const body = {};
+        if (input?.newVersion !== void 0) body.newVersion = input.newVersion;
+        return transport.request({
+          method: "POST",
+          path: `/v1/proposals/${encodeURIComponent(id)}/apply`,
+          headers: supervisorHeader(supervisorId),
+          body,
+          ...input?.idempotencyKey !== void 0 && { idempotencyKey: input.idempotencyKey }
+        });
+      },
+      async rollback(supervisorId, id, input) {
+        return transport.request({
+          method: "POST",
+          path: `/v1/proposals/${encodeURIComponent(id)}/rollback`,
+          headers: supervisorHeader(supervisorId),
+          body: { reason: input.reason },
+          ...input.idempotencyKey !== void 0 && { idempotencyKey: input.idempotencyKey }
+        });
+      },
+      async withdraw(supervisorId, id, input) {
+        return transport.request({
+          method: "POST",
+          path: `/v1/proposals/${encodeURIComponent(id)}/withdraw`,
+          headers: supervisorHeader(supervisorId),
+          body: { reason: input.reason },
+          ...input.idempotencyKey !== void 0 && { idempotencyKey: input.idempotencyKey }
+        });
+      }
+    }
+  };
+}
+
+// src/resources/teams.ts
+function makeTeamsClient(transport) {
+  const seg = (s) => encodeURIComponent(s);
+  return {
+    async create(input, options) {
+      return transport.request({
+        method: "POST",
+        path: "/v1/teams",
+        body: input,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async list(filter) {
+      return transport.request({
+        method: "GET",
+        path: "/v1/teams",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor }
+        }
+      });
+    },
+    async get(teamId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/teams/${seg(teamId)}`
+      });
+    },
+    async update(teamId, input, options) {
+      return transport.request({
+        method: "PATCH",
+        path: `/v1/teams/${seg(teamId)}`,
+        body: input,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async delete(teamId) {
+      return transport.request({
+        method: "DELETE",
+        path: `/v1/teams/${seg(teamId)}`,
+        discardResponse: true
+      });
+    },
+    memberships: {
+      async list(teamId, filter) {
+        return transport.request({
+          method: "GET",
+          path: `/v1/teams/${seg(teamId)}/memberships`,
+          query: {
+            ...filter?.limit !== void 0 && { limit: filter.limit },
+            ...filter?.cursor !== void 0 && { cursor: filter.cursor }
+          }
+        });
+      },
+      async add(teamId, input, options) {
+        return transport.request({
+          method: "POST",
+          path: `/v1/teams/${seg(teamId)}/memberships`,
+          body: input,
+          ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+        });
+      },
+      async updateRole(teamId, userId, role, options) {
+        return transport.request({
+          method: "PATCH",
+          path: `/v1/teams/${seg(teamId)}/memberships/${seg(userId)}`,
+          body: { role },
+          discardResponse: true,
+          ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+        });
+      },
+      async remove(teamId, userId, options) {
+        return transport.request({
+          method: "DELETE",
+          path: `/v1/teams/${seg(teamId)}/memberships/${seg(userId)}`,
+          discardResponse: true,
+          ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+        });
+      }
+    }
+  };
+}
+
+// src/resources/tenant.ts
+function makeTenantClient(transport) {
+  return {
+    async get() {
+      return transport.request({
+        method: "GET",
+        path: "/v1/tenant"
+      });
+    },
+    config: {
+      async list(filter) {
+        return transport.request({
+          method: "GET",
+          path: "/v1/tenant/config",
+          query: {
+            ...filter?.limit !== void 0 && { limit: filter.limit },
+            ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+            ...filter?.kind !== void 0 && { kind: filter.kind },
+            ...filter?.keyPrefix !== void 0 && { keyPrefix: filter.keyPrefix }
+          }
+        });
+      },
+      async upsert(input, options) {
+        return transport.request({
+          method: "PATCH",
+          path: "/v1/tenant/config",
+          body: input,
+          ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+        });
+      }
+    }
+  };
+}
+
+// src/resources/tokens.ts
+function fromWire2(wire) {
+  return {
+    id: wire.tokenId,
+    role: wire.role,
+    capabilities: wire.capabilities,
+    ...wire.label !== void 0 && { label: wire.label },
+    ...wire.projectId !== void 0 && {
+      projectId: wire.projectId
+    },
+    ...wire.createdBy !== void 0 && { createdBy: wire.createdBy },
+    createdAt: wire.createdAt,
+    ...wire.lastUsedAt !== void 0 && { lastUsedAt: wire.lastUsedAt },
+    ...wire.expiresAt !== void 0 && { expiresAt: wire.expiresAt },
+    ...wire.revokedAt !== void 0 && { revokedAt: wire.revokedAt }
+  };
+}
+function makeTokensClient(transport) {
+  return {
+    async create(spec, options) {
+      const body = {};
+      if (spec?.role !== void 0) body.role = spec.role;
+      if (spec?.capabilities !== void 0) body.capabilities = spec.capabilities;
+      if (spec?.label !== void 0) body.label = spec.label;
+      if (spec?.expiresAt !== void 0) body.expiresAt = spec.expiresAt;
+      if (spec?.projectId !== void 0) body.projectId = spec.projectId;
+      const wire = await transport.request({
+        method: "POST",
+        path: "/v1/tokens",
+        body,
+        ...options?.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+      const { token, ...record } = wire;
+      return { meta: fromWire2(record), secret: token };
+    },
+    async list(filter) {
+      const page = await transport.request({
+        method: "GET",
+        path: "/v1/tokens",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor }
+        }
+      });
+      return {
+        items: page.data.map(fromWire2),
+        ...page.nextCursor !== void 0 && { nextCursor: page.nextCursor }
+      };
+    },
+    async get(id) {
+      const wire = await transport.request({
+        method: "GET",
+        path: `/v1/tokens/${encodeURIComponent(id)}`
+      });
+      return fromWire2(wire);
+    },
+    async createPublic(input, options) {
+      return transport.request({
+        method: "POST",
+        path: "/v1/tokens/public",
+        body: input,
+        ...options?.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+    },
+    async revoke(id, options) {
+      await transport.request({
+        method: "POST",
+        path: `/v1/tokens/${encodeURIComponent(id)}/revoke`,
+        body: {},
+        discardResponse: true,
+        ...options?.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+    }
+  };
+}
+
+// src/resources/tools.ts
+function makeToolsClient(transport) {
+  return {
+    async list(filter) {
+      const page = await transport.request({
+        method: "GET",
+        path: "/v1/tools",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.name !== void 0 && { name: filter.name }
+        }
+      });
+      return {
+        items: page.data,
+        ...page.nextCursor !== void 0 && { nextCursor: page.nextCursor }
+      };
+    },
+    async get(id) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/tools/${encodeURIComponent(id)}`
+      });
+    },
+    async listVersions(id, filter) {
+      const page = await transport.request({
+        method: "GET",
+        path: `/v1/tools/${encodeURIComponent(id)}/versions`,
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.includeTombstoned === true && { includeTombstoned: "true" }
+        }
+      });
+      return {
+        items: page.data,
+        ...page.nextCursor !== void 0 && { nextCursor: page.nextCursor }
+      };
+    },
+    async getVersion(id, version) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/tools/${encodeURIComponent(id)}/versions/${encodeURIComponent(version)}`
+      });
+    },
+    async reinstateVersion(id, version, options) {
+      const wire = await transport.request({
+        method: "POST",
+        path: `/v1/tools/${encodeURIComponent(id)}/versions/${encodeURIComponent(version)}/reinstate`,
+        ...options?.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+      return {
+        toolId: wire.toolId,
+        version: wire.version,
+        wasTombstoned: wire.wasTombstoned
+      };
+    },
+    async unregisterVersion(id, version, options) {
+      const wire = await transport.request({
+        method: "POST",
+        path: `/v1/tools/${encodeURIComponent(id)}/versions/${encodeURIComponent(version)}/unregister`,
+        ...options?.idempotencyKey !== void 0 && {
+          idempotencyKey: options.idempotencyKey
+        }
+      });
+      return {
+        toolId: wire.toolId,
+        version: wire.version,
+        unregistered: wire.unregistered
+      };
+    },
+    async invoke(_id, _input) {
+      throw new KindgiApiError(
+        notYetWired(
+          "tools.invoke",
+          "no POST /v1/tools/{toolId}/invoke route on the API \u2014 direct invocation surface unrouted"
+        )
+      );
+    },
+    async manifests(_filter) {
+      throw new KindgiApiError(
+        notYetWired(
+          "tools.manifests",
+          "the wire `Tool` is the manifest; the API has no separate manifests endpoint"
+        )
+      );
+    }
+  };
+}
+
+// src/resources/users.ts
+function makeUsersClient(transport) {
+  return {
+    async create(_spec) {
+      throw new KindgiApiError(
+        notYetWired(
+          "users.create",
+          "no user-creation route on the wire \u2014 framework does NOT own user persistence (deployments plug LDAP / SCIM / bespoke stores via IdentityDirectoryBinding)"
+        )
+      );
+    },
+    async get(id) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/identity/users/${encodeURIComponent(id)}`
+      });
+    },
+    async me() {
+      return transport.request({
+        method: "GET",
+        path: "/v1/identity/whoami"
+      });
+    },
+    async list(filter) {
+      const page = await transport.request({
+        method: "GET",
+        path: "/v1/identity/users",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.query !== void 0 && { query: filter.query }
+        }
+      });
+      return {
+        items: page.data,
+        ...page.nextCursor !== void 0 && {
+          nextCursor: page.nextCursor
+        }
+      };
+    },
+    async update(_id, _patch) {
+      throw new KindgiApiError(
+        notYetWired(
+          "users.update",
+          "no user-update route on the wire \u2014 framework does NOT own user persistence"
+        )
+      );
+    },
+    async deactivate(_id) {
+      throw new KindgiApiError(
+        notYetWired(
+          "users.deactivate",
+          "no user-deactivate route on the wire \u2014 framework does NOT own user persistence"
+        )
+      );
+    },
+    sessions: {
+      async list(userId) {
+        const page = await transport.request({
+          method: "GET",
+          path: `/v1/identity/users/${encodeURIComponent(userId)}/sessions`
+        });
+        return {
+          items: page.data,
+          ...page.nextCursor !== void 0 && {
+            nextCursor: page.nextCursor
+          }
+        };
+      },
+      async revokeAll(userId, options) {
+        return transport.request({
+          method: "POST",
+          path: `/v1/identity/users/${encodeURIComponent(userId)}/revoke-sessions`,
+          body: {},
+          ...options?.idempotencyKey !== void 0 && {
+            idempotencyKey: options.idempotencyKey
+          }
+        });
+      },
+      async revoke(_id) {
+        throw new KindgiApiError(
+          notYetWired(
+            "users.sessions.revoke",
+            "no per-session revoke route on the wire \u2014 wire revokes ALL sessions for a user via revokeAll(userId); per-session revoke has design merit but no route yet"
+          )
+        );
+      }
+    }
+  };
+}
+
+// src/resources/webhook-endpoints.ts
+function makeWebhookEndpointsClient(transport) {
+  const idempotency = (options) => options?.idempotencyKey !== void 0 ? { idempotencyKey: options.idempotencyKey } : {};
+  return {
+    async create(input, options) {
+      return transport.request({
+        method: "POST",
+        path: "/v1/webhook-endpoints",
+        body: input,
+        ...idempotency(options)
+      });
+    },
+    async generateSecret() {
+      return transport.request({
+        method: "POST",
+        path: "/v1/webhook-endpoints/generate-secret"
+      });
+    },
+    async list(filter) {
+      return transport.request({
+        method: "GET",
+        path: "/v1/webhook-endpoints",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor }
+        }
+      });
+    },
+    async get(endpointId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/webhook-endpoints/${encodeURIComponent(endpointId)}`
+      });
+    },
+    async update(endpointId, input, options) {
+      return transport.request({
+        method: "PATCH",
+        path: `/v1/webhook-endpoints/${encodeURIComponent(endpointId)}`,
+        body: input,
+        ...idempotency(options)
+      });
+    },
+    async unregister(endpointId, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/webhook-endpoints/${encodeURIComponent(endpointId)}/unregister`,
+        ...idempotency(options)
+      });
+    },
+    async listDeliveries(endpointId, filter) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/webhook-endpoints/${encodeURIComponent(endpointId)}/deliveries`,
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.status !== void 0 && { status: filter.status }
+        }
+      });
+    },
+    async redeliver(endpointId, deliveryId, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/webhook-endpoints/${encodeURIComponent(endpointId)}/deliveries/${encodeURIComponent(deliveryId)}/redeliver`,
+        ...idempotency(options)
+      });
+    },
+    async sendTest(endpointId, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/webhook-endpoints/${encodeURIComponent(endpointId)}/test`,
+        ...idempotency(options)
+      });
+    }
+  };
+}
+
+// src/resources/webhooks.ts
+function makeWebhooksClient(transport) {
+  return {
+    async register(input, options) {
+      return transport.request({
+        method: "POST",
+        path: "/v1/webhooks",
+        body: input,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async list(filter) {
+      return transport.request({
+        method: "GET",
+        path: "/v1/webhooks",
+        query: {
+          ...filter?.limit !== void 0 && { limit: filter.limit },
+          ...filter?.cursor !== void 0 && { cursor: filter.cursor },
+          ...filter?.status !== void 0 && { status: filter.status }
+        }
+      });
+    },
+    async get(triggerId) {
+      return transport.request({
+        method: "GET",
+        path: `/v1/webhooks/${encodeURIComponent(triggerId)}`
+      });
+    },
+    async update(triggerId, input, options) {
+      return transport.request({
+        method: "PATCH",
+        path: `/v1/webhooks/${encodeURIComponent(triggerId)}`,
+        body: input,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async pause(triggerId, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/webhooks/${encodeURIComponent(triggerId)}/pause`,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async resume(triggerId, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/webhooks/${encodeURIComponent(triggerId)}/resume`,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    },
+    async unregister(triggerId, options) {
+      return transport.request({
+        method: "POST",
+        path: `/v1/webhooks/${encodeURIComponent(triggerId)}/unregister`,
+        ...options?.idempotencyKey !== void 0 && { idempotencyKey: options.idempotencyKey }
+      });
+    }
+  };
+}
+
+// src/transport.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MUTATING = /* @__PURE__ */ new Set([
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE"
+]);
+function createTransport(options) {
+  const apiUrl = options.apiUrl.replace(/\/+$/u, "");
+  const fetchImpl = options.fetch ?? fetch;
+  const clientTimeoutMs = DEFAULT_TIMEOUT_MS;
+  return {
+    apiUrl,
+    fetchImpl,
+    authHeaders() {
+      return { Authorization: `Bearer ${authTokenFor(options.auth)}` };
+    },
+    async request(input) {
+      const url = buildUrl(apiUrl, input.path, input.query);
+      const headers = buildHeaders(input, options.auth);
+      const timeoutMs = input.timeoutMs ?? clientTimeoutMs;
+      const ac = new AbortController();
+      const timer = setTimeout(
+        () => ac.abort(new Error("timeout")),
+        timeoutMs
+      );
+      let response;
+      try {
+        response = await fetchImpl(url, {
+          method: input.method,
+          headers,
+          ...input.body !== void 0 && { body: JSON.stringify(input.body) },
+          signal: ac.signal
+        });
+      } catch (cause) {
+        clearTimeout(timer);
+        const err = {
+          code: "network",
+          message: cause instanceof Error ? cause.message : "network request failed",
+          cause
+        };
+        throw new KindgiApiError(err);
+      }
+      clearTimeout(timer);
+      if (response.ok) {
+        if (input.discardResponse === true || response.status === 204) {
+          try {
+            await response.arrayBuffer();
+          } catch {
+          }
+          return void 0;
+        }
+        try {
+          return await response.json();
+        } catch (cause) {
+          const err = {
+            code: "network",
+            message: "Response body was not valid JSON",
+            cause
+          };
+          throw new KindgiApiError(err);
+        }
+      }
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        body = void 0;
+      }
+      throw new KindgiApiError(fromWire(unwrapErrorEnvelope(body, response.status)));
+    }
+  };
+}
+function buildUrl(apiUrl, path, query) {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  const base = `${apiUrl}${normalizedPath}`;
+  if (query === void 0) return base;
+  const params = [];
+  for (const key of Object.keys(query)) {
+    const value = query[key];
+    if (value === void 0) continue;
+    params.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  }
+  return params.length === 0 ? base : `${base}?${params.join("&")}`;
+}
+function buildHeaders(input, auth) {
+  const headers = {
+    Accept: "application/json",
+    Authorization: `Bearer ${authTokenFor(auth)}`
+  };
+  if (input.body !== void 0) {
+    headers["Content-Type"] = "application/json; charset=utf-8";
+  }
+  if (input.idempotencyKey !== void 0 && MUTATING.has(input.method)) {
+    headers["Idempotency-Key"] = input.idempotencyKey;
+  }
+  if (input.headers !== void 0) {
+    for (const key of Object.keys(input.headers)) {
+      headers[key] = input.headers[key];
+    }
+  }
+  return headers;
+}
+function authTokenFor(auth) {
+  if (auth.kind === "apiToken") return auth.token;
+  return auth.accessToken;
+}
+function unwrapErrorEnvelope(body, status) {
+  if (body !== null && typeof body === "object" && !Array.isArray(body)) {
+    const inner = body.error;
+    if (inner !== null && typeof inner === "object" && !Array.isArray(inner)) {
+      return inner;
+    }
+  }
+  return { code: "unknown", message: `HTTP ${status} without recognizable error envelope` };
+}
+
+// src/client.ts
+function createClient(options) {
+  const transport = createTransport(options);
+  return {
+    agents: makeAgentsClient(transport),
+    flows: makeFlowsClient(transport),
+    tools: makeToolsClient(transport),
+    guardrails: makeGuardrailsClient(transport),
+    runs: makeRunsClient(transport),
+    schedules: makeSchedulesClient(transport),
+    conversations: makeConversationsClient(transport),
+    memory: makeMemoryClient(transport),
+    provenance: makeProvenanceClient(transport),
+    supervisor: makeSupervisorClient(transport),
+    observations: makeObservationsClient(transport),
+    approvals: makeApprovalsClient(transport),
+    tenant: makeTenantClient(transport),
+    cost: makeCostClient(transport),
+    capabilities: makeCapabilitiesClient(transport),
+    adapters: makeAdaptersClient(transport),
+    providers: makeProvidersClient(transport),
+    policies: makePoliciesClient(transport),
+    projects: makeProjectsClient(transport),
+    env: makeEnvClient(transport),
+    secrets: makeSecretsClient(transport),
+    deployments: makeDeploymentsClient(transport),
+    compliance: makeComplianceClient(transport),
+    audit: makeAuditClient(transport),
+    evalSuites: makeEvalSuitesClient(transport),
+    evalRuns: makeEvalRunsClient(transport),
+    users: makeUsersClient(transport),
+    identity: makeIdentityClient(transport),
+    auth: makeAuthClient(transport),
+    teams: makeTeamsClient(transport),
+    orgs: makeOrgsClient(transport),
+    signingKeys: makeSigningKeysClient(transport),
+    tokens: makeTokensClient(transport),
+    mcp: makeMcpClient(transport),
+    events: makeEventsClient(),
+    eventTriggers: makeEventTriggersClient(transport),
+    artifacts: makeArtifactsClient(transport),
+    webhooks: makeWebhooksClient(transport),
+    webhookEndpoints: makeWebhookEndpointsClient(transport),
+    packs: makePacksClient()
+  };
+}
+
+export { KindgiApiError, SseHttpError, createClient, followRun, fromWire, notImplementedInPreview, notYetWired, readSse, subscribeToRun, unwrapSseData };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map