@mgcrea/mcp-loki 0.0.0 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Olivier Louvignes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,91 @@
 # @mgcrea/mcp-loki
 
-Placeholder. See https://github.com/mgcrea/mcp-loki
+A [Model Context Protocol](https://modelcontextprotocol.io) server for the
+[Grafana Loki](https://grafana.com/oss/loki/) HTTP API: query logs and LogQL metrics, explore
+labels, fields, volume and patterns, with answers shaped to fit a context window.
+
+The server is **read-only**. It sends only reads: Loki's push, delete-request and ruler-write
+endpoints are not wrapped, and the `loki_request` escape hatch only sends GET.
+
+## Features
+
+- **Logs merged across streams, in time order.** Labels every stream shares come once as
+  `common_labels`. Each line keeps only the labels that tell its stream apart, plus `level` and
+  structured metadata. Timestamps are exact RFC3339 nanoseconds, so the `next` cursor and
+  `loki_get_log_context` anchors round-trip without loss.
+- **Cheap before expensive.** `loki_get_stats` and `loki_get_volume` answer from the index
+  without reading a line. `loki_list_patterns` summarizes what a service logs as templates.
+  `loki_query_metric` counts and ranks without returning lines.
+- **Long lines are cut** at `max_line_chars` (some services log 300 KB lines), ANSI colour
+  codes are stripped, and the Kubernetes `filename` label is hidden by default.
+- **Errors carry a remedy.** Loki answers a rejected query with plain text. The common ones
+  (empty-compatible matchers, parse errors, range and series limits, timeouts) come back with
+  what to change.
+- **Identity and limits up front.** `loki_auth_status` names the tenant, the version,
+  retention, max query length, max lines and series per query, and whether volume and patterns
+  are enabled. Every data answer carries `tenant`.
+
+## Configure
+
+| Variable           | Required | Description                                                                                                                      |
+| ------------------ | -------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| `LOKI_URL`         | yes      | Loki base URL (gateway, query-frontend or single binary), with any path prefix.                                                  |
+| `LOKI_USERNAME`    | no       | Basic auth. Behind the Loki Helm chart's nginx gateway the username **is the tenant**.                                           |
+| `LOKI_PASSWORD`    | no       | Basic auth password.                                                                                                             |
+| `LOKI_TOKEN`       | no       | Bearer token instead of basic auth (Grafana Cloud, an OAuth proxy).                                                              |
+| `LOKI_TENANT_ID`   | no       | Sent as `X-Scope-OrgID`, for a multi-tenant Loki reached directly. A gateway that maps the basic-auth username overrides it.     |
+| `LOKI_HEADERS`     | no       | Extra headers as a JSON object.                                                                                                  |
+| `LOKI_TIMEOUT`     | no       | HTTP timeout per request, seconds (default 60).                                                                                  |
+| `LOKI_MAX_RETRIES` | no       | Retries for 429 and proxy 502/503 (default 2). A 504 is never retried: on Loki it is a slow query, and a retry triples the load. |
+
+With nothing configured the server still starts and serves `loki_auth_status`, which says what
+to set.
+
+## Quick start
+
+```bash
+pnpm install
+pnpm build
+```
+
+Then copy `.mcp.json.example` to `.mcp.json` and fill it in.
+
+## Tools
+
+| Tool                        | What it does                                                                       |
+| --------------------------- | ---------------------------------------------------------------------------------- |
+| `loki_auth_status`          | URL, auth, tenant, version and this tenant's limits; setup steps when unconfigured |
+| `loki_query_logs`           | LogQL log query over a range, lines merged across streams, with a `next` cursor    |
+| `loki_get_log_context`      | The lines just before and after one line, in its own stream                        |
+| `loki_query_metric`         | LogQL metric query at an instant, ranked largest first                             |
+| `loki_query_metric_range`   | LogQL metric query over a range, on a step grid, with per-series stats             |
+| `loki_list_labels`          | Stream labels with their cardinality                                               |
+| `loki_list_label_values`    | Values of one label, optionally within a selector                                  |
+| `loki_list_series`          | Streams matching a selector                                                        |
+| `loki_list_detected_fields` | JSON / logfmt / structured-metadata fields in the lines, or one field's values     |
+| `loki_get_volume`           | Bytes per namespace / app / stream from the index, largest first                   |
+| `loki_get_stats`            | Streams, chunks, lines and bytes a selector covers, from the index                 |
+| `loki_list_patterns`        | Line templates with counts, from the pattern ingester                              |
+| `loki_list_rules`           | The Loki ruler's alerting and recording rules                                      |
+| `loki_request`              | GET any other read endpoint (`/loki/api/v1/*`, `/prometheus/api/v1/*`, `/config`)  |
+
+## Develop
+
+```bash
+pnpm dev            # tsdown --watch
+pnpm test           # vitest
+pnpm typecheck
+pnpm lint
+pnpm format
+```
+
+### Publish
+
+```bash
+pnpm dlx release-it       # bump, commit, tag
+git push --follow-tags    # CI publishes to npm from the tag
+```
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/cli.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { _ as BUILD_INFO, f as authMode, g as setupInstructions, i as createServer, m as loadConfig, p as isConfigured, s as describeError } from "./server-B2TOeJ3P.js";
+import { ZodError } from "zod";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+// src/cli.ts
+const stderrLogger = {
+	debug: (...args) => {
+		if (process.env.LOKI_DEBUG) console.error("[loki-mcp]", ...args);
+	},
+	warn: (...args) => console.error("[loki-mcp]", ...args),
+	error: (...args) => console.error("[loki-mcp]", ...args)
+};
+/** Show a config mistake as its field messages, not 40 frames of zod internals. */
+const describeFatal = (err) => {
+	if (err instanceof ZodError) return err.issues.map((issue) => {
+		const path = issue.path.join(".");
+		return path ? `${path}: ${issue.message}` : issue.message;
+	}).join("\n");
+	return err instanceof Error ? err.message : String(err);
+};
+const main = async () => {
+	stderrLogger.warn(`${BUILD_INFO.name}@${BUILD_INFO.version} (git ${BUILD_INFO.gitCommit} ${BUILD_INFO.gitCommitDate}, node ${process.version})`);
+	const config = loadConfig();
+	const { server, ctx } = createServer({
+		config,
+		logger: stderrLogger
+	});
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+	stderrLogger.warn(`loki-mcp connected (url=${config.url ?? "MISSING"}, auth=${authMode(config)}, tenant=${ctx.tenant?.tenant ?? "none"}, read-only)`);
+	for (const line of setupInstructions(config)) stderrLogger.warn(line);
+	if (isConfigured(config)) ctx.identity().then((id) => {
+		const l = id.limits ?? {};
+		stderrLogger.warn(`loki ${id.version ?? "?"} at ${new URL(config.url).host}` + (ctx.tenant ? `, tenant ${ctx.tenant.tenant}` : "") + (l.retention ? `, retention ${l.retention}` : "") + (l.maxQueryLength ? `, max range ${l.maxQueryLength}` : ""));
+	}).catch((err) => {
+		const { error, remedy } = describeError(err);
+		stderrLogger.warn(`loki unreachable: ${error}${remedy ? ` — ${String(remedy)}` : ""}`);
+	});
+	const shutdown = (signal) => {
+		stderrLogger.warn(`received ${signal}, shutting down`);
+		process.exit(0);
+	};
+	process.on("SIGINT", () => shutdown("SIGINT"));
+	process.on("SIGTERM", () => shutdown("SIGTERM"));
+};
+main().catch((err) => {
+	console.error(`[loki-mcp] fatal: ${describeFatal(err)}`);
+	process.exit(1);
+});
+export {};
+
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","names":[],"sources":["../src/cli.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { StdioServerTransport } from \"@modelcontextprotocol/server/stdio\";\nimport { ZodError } from \"zod\";\n\nimport { BUILD_INFO } from \"#/build-info\";\nimport { authMode, isConfigured, loadConfig, setupInstructions } from \"#/config\";\nimport { createServer } from \"#/server\";\nimport { describeError } from \"#/tools/util\";\n\n// Everything goes to stderr: stdout is the MCP protocol channel, and a stray\n// log line there corrupts the stream.\nconst stderrLogger = {\n  debug: (...args: unknown[]) => {\n    if (process.env.LOKI_DEBUG) console.error(\"[loki-mcp]\", ...args);\n  },\n  warn: (...args: unknown[]) => console.error(\"[loki-mcp]\", ...args),\n  error: (...args: unknown[]) => console.error(\"[loki-mcp]\", ...args),\n};\n\n/** Show a config mistake as its field messages, not 40 frames of zod internals. */\nconst describeFatal = (err: unknown): string => {\n  if (err instanceof ZodError) {\n    return err.issues\n      .map((issue) => {\n        const path = issue.path.join(\".\");\n        return path ? `${path}: ${issue.message}` : issue.message;\n      })\n      .join(\"\\n\");\n  }\n  return err instanceof Error ? err.message : String(err);\n};\n\nconst main = async (): Promise<void> => {\n  stderrLogger.warn(\n    `${BUILD_INFO.name}@${BUILD_INFO.version} (git ${BUILD_INFO.gitCommit} ${BUILD_INFO.gitCommitDate}, node ${process.version})`,\n  );\n  const config = loadConfig();\n  const { server, ctx } = createServer({ config, logger: stderrLogger });\n  const transport = new StdioServerTransport();\n  await server.connect(transport);\n  stderrLogger.warn(\n    `loki-mcp connected (url=${config.url ?? \"MISSING\"}, auth=${authMode(config)}, ` +\n      `tenant=${ctx.tenant?.tenant ?? \"none\"}, read-only)`,\n  );\n  for (const line of setupInstructions(config)) stderrLogger.warn(line);\n\n  // Which Loki answered, after connecting so a slow one never delays the\n  // handshake. The tenant line scrolling past is the cheapest chance to notice\n  // a credential copied from the wrong project.\n  if (isConfigured(config)) {\n    ctx\n      .identity()\n      .then((id) => {\n        const l = id.limits ?? {};\n        stderrLogger.warn(\n          `loki ${id.version ?? \"?\"} at ${new URL(config.url as string).host}` +\n            (ctx.tenant ? `, tenant ${ctx.tenant.tenant}` : \"\") +\n            (l.retention ? `, retention ${l.retention}` : \"\") +\n            (l.maxQueryLength ? `, max range ${l.maxQueryLength}` : \"\"),\n        );\n      })\n      .catch((err: unknown) => {\n        const { error, remedy } = describeError(err);\n        stderrLogger.warn(`loki unreachable: ${error}${remedy ? ` — ${String(remedy)}` : \"\"}`);\n      });\n  }\n\n  const shutdown = (signal: string): void => {\n    stderrLogger.warn(`received ${signal}, shutting down`);\n    process.exit(0);\n  };\n  process.on(\"SIGINT\", () => shutdown(\"SIGINT\"));\n  process.on(\"SIGTERM\", () => shutdown(\"SIGTERM\"));\n};\n\nmain().catch((err: unknown) => {\n  console.error(`[loki-mcp] fatal: ${describeFatal(err)}`);\n  process.exit(1);\n});\n"],"mappings":";;;;;AAWA,MAAM,eAAe;CACnB,QAAQ,GAAG,SAAoB;EAC7B,IAAI,QAAQ,IAAI,YAAY,QAAQ,MAAM,cAAc,GAAG,IAAI;CACjE;CACA,OAAO,GAAG,SAAoB,QAAQ,MAAM,cAAc,GAAG,IAAI;CACjE,QAAQ,GAAG,SAAoB,QAAQ,MAAM,cAAc,GAAG,IAAI;AACpE;;AAGA,MAAM,iBAAiB,QAAyB;CAC9C,IAAI,eAAe,UACjB,OAAO,IAAI,OACR,KAAK,UAAU;EACd,MAAM,OAAO,MAAM,KAAK,KAAK,GAAG;EAChC,OAAO,OAAO,GAAG,KAAK,IAAI,MAAM,YAAY,MAAM;CACpD,CAAC,CAAC,CACD,KAAK,IAAI;CAEd,OAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;AACxD;AAEA,MAAM,OAAO,YAA2B;CACtC,aAAa,KACX,GAAG,WAAW,KAAK,GAAG,WAAW,QAAQ,QAAQ,WAAW,UAAU,GAAG,WAAW,cAAc,SAAS,QAAQ,QAAQ,EAC7H;CACA,MAAM,SAAS,WAAW;CAC1B,MAAM,EAAE,QAAQ,QAAQ,aAAa;EAAE;EAAQ,QAAQ;CAAa,CAAC;CACrE,MAAM,YAAY,IAAI,qBAAqB;CAC3C,MAAM,OAAO,QAAQ,SAAS;CAC9B,aAAa,KACX,2BAA2B,OAAO,OAAO,UAAU,SAAS,SAAS,MAAM,EAAE,WACjE,IAAI,QAAQ,UAAU,OAAO,aAC3C;CACA,KAAK,MAAM,QAAQ,kBAAkB,MAAM,GAAG,aAAa,KAAK,IAAI;CAKpE,IAAI,aAAa,MAAM,GACrB,IACG,SAAS,CAAC,CACV,MAAM,OAAO;EACZ,MAAM,IAAI,GAAG,UAAU,CAAC;EACxB,aAAa,KACX,QAAQ,GAAG,WAAW,IAAI,MAAM,IAAI,IAAI,OAAO,GAAa,CAAC,CAAC,UAC3D,IAAI,SAAS,YAAY,IAAI,OAAO,WAAW,OAC/C,EAAE,YAAY,eAAe,EAAE,cAAc,OAC7C,EAAE,iBAAiB,eAAe,EAAE,mBAAmB,GAC5D;CACF,CAAC,CAAC,CACD,OAAO,QAAiB;EACvB,MAAM,EAAE,OAAO,WAAW,cAAc,GAAG;EAC3C,aAAa,KAAK,qBAAqB,QAAQ,SAAS,MAAM,OAAO,MAAM,MAAM,IAAI;CACvF,CAAC;CAGL,MAAM,YAAY,WAAyB;EACzC,aAAa,KAAK,YAAY,OAAO,gBAAgB;EACrD,QAAQ,KAAK,CAAC;CAChB;CACA,QAAQ,GAAG,gBAAgB,SAAS,QAAQ,CAAC;CAC7C,QAAQ,GAAG,iBAAiB,SAAS,SAAS,CAAC;AACjD;AAEA,KAAK,CAAC,CAAC,OAAO,QAAiB;CAC7B,QAAQ,MAAM,qBAAqB,cAAc,GAAG,GAAG;CACvD,QAAQ,KAAK,CAAC;AAChB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,168 @@
+import { McpServer } from "@modelcontextprotocol/server";
+import { z } from "zod";
+declare const ConfigSchema: z.ZodObject<{
+  url: z.ZodOptional<z.ZodURL>;
+  username: z.ZodOptional<z.ZodString>;
+  password: z.ZodOptional<z.ZodString>;
+  token: z.ZodOptional<z.ZodString>;
+  tenantId: z.ZodOptional<z.ZodString>;
+  headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+  timeoutSeconds: z.ZodDefault<z.ZodNumber>;
+  maxRetries: z.ZodDefault<z.ZodNumber>;
+  problems: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+type Config = z.infer<typeof ConfigSchema>;
+type AuthMode = "basic" | "bearer" | "none";
+/**
+ * Environment only: the server persists nothing of its own, so there is no
+ * config file to merge with.
+ */
+export declare const loadConfig: (env?: NodeJS.ProcessEnv) => Config;
+export declare const authMode: (config: Config) => AuthMode;
+/** A URL and no contradictions. A local Loki needs no auth, so none is required. */
+export declare const isConfigured: (config: Config) => boolean;
+type Tenant = {
+  tenant: string;
+  source: string;
+};
+/**
+ * Which tenant's logs every answer comes from. Loki never echoes it back — no
+ * endpoint says "you are tenant X" — so this is what the server sends or what
+ * the gateway is known to derive, and it is labelled as such.
+ *
+ * The Loki chart's nginx gateway with basicAuth sets `X-Scope-OrgID` from the
+ * basic-auth username and overwrites any header the client sent (observed on
+ * Loki 3.7.9 / chart 20.2.1: a bogus X-Scope-OrgID still answered with the
+ * user's tenant). So with basic auth the username is the tenant, and a
+ * LOKI_TENANT_ID beside it is probably ignored.
+ */
+export declare const resolveTenant: (config: Config) => Tenant | undefined;
+/** Returned by loki_auth_status and printed to stderr at startup. */
+export declare const setupInstructions: (config: Config) => string[];
+type Logger = {
+  debug?(...args: unknown[]): void;
+  warn?(...args: unknown[]): void;
+  error?(...args: unknown[]): void;
+};
+/**
+ * The headers every request carries. Loki has no login of its own: basic or
+ * bearer auth satisfies whatever sits in front of it (the chart's nginx
+ * gateway, an ingress, Grafana Cloud), and `X-Scope-OrgID` picks the tenant
+ * when Loki runs with `auth_enabled: true`. Nothing to refresh, so a 401 is
+ * always final.
+ */
+export declare const authHeaders: (config: Config) => Record<string, string>;
+/** Repeated keys (`match[]`) are arrays; undefined values are dropped. */
+type Params = Record<string, string | number | bigint | boolean | string[] | undefined>;
+type LokiResult<T> = {
+  data: T;
+  warnings?: string[];
+};
+type LokiClientOptions = {
+  baseUrl: string;
+  headers: Record<string, string>;
+  timeoutSeconds: number;
+  maxRetries: number;
+  userAgent: string;
+  fetch?: typeof fetch;
+  logger?: Logger;
+};
+export declare class LokiClient {
+  readonly baseUrl: string;
+  readonly timeoutSeconds: number;
+  private readonly headers;
+  private readonly maxRetries;
+  private readonly userAgent;
+  private readonly fetchImpl;
+  private readonly logger;
+  constructor(opts: LokiClientOptions);
+  get<T = unknown>(path: string, params?: Params, headers?: Record<string, string>): Promise<LokiResult<T>>;
+  /** A read on an endpoint that also takes a form POST: GET unless the URL would be too long. */
+  read<T = unknown>(path: string, params: Params, headers?: Record<string, string>): Promise<LokiResult<T>>;
+  request<T = unknown>(method: "GET" | "POST", path: string, opts?: {
+    params?: Params;
+    form?: Params;
+    headers?: Record<string, string>;
+  }): Promise<LokiResult<T>>;
+}
+type Limits = {
+  retention?: string;
+  maxQueryLength?: string;
+  maxQueryRange?: string;
+  maxQueryLookback?: string;
+  maxEntriesPerQuery?: number;
+  maxQuerySeries?: number;
+  maxQueryBytesRead?: string;
+  queryTimeout?: string;
+  volumeEnabled?: boolean;
+  patternIngesterEnabled?: boolean;
+  discoverLogLevels?: boolean;
+};
+type Identity = {
+  version?: string;
+  revision?: string;
+  limits?: Limits;
+  /** Endpoints that did not answer: normal on older Loki or a gateway that does not route them. */
+  unavailable?: string[];
+};
+export declare const fetchIdentity: (client: LokiClient) => Promise<Identity>;
+type ToolContext = {
+  config: Config;
+  hasCredentials: boolean;
+  /** The tenant every answer is read from, as far as the configuration says. */
+  tenant: Tenant | undefined;
+  /**
+   * Spread first into every data answer. A credential copied from another
+   * tenant answers every query with plausible logs from that tenant, so each
+   * answer says whose logs they are.
+   */
+  tag: () => {
+    tenant?: string;
+  };
+  /** Who answered and what it allows, memoized after the first success. */
+  identity: () => Promise<Identity>;
+  /** Seconds since the epoch; injectable so tests can pin relative times. */
+  now: () => number;
+};
+export declare const createToolContext: (client: LokiClient, config: Config, hasCredentials: boolean, now?: () => number) => ToolContext;
+/**
+ * Register the tools. Every tool is a read: Loki's mutating endpoints (push,
+ * the compactor's delete requests, ruler writes) are deliberately not wrapped,
+ * so there is no write flag. `loki_request` is GET-only.
+ */
+export declare const registerTools: (server: McpServer, client: LokiClient, ctx: ToolContext) => void;
+export declare const SERVER_NAME: string;
+export declare const SERVER_VERSION: string;
+export declare const USER_AGENT: string;
+type CreateServerOptions = {
+  config: Config;
+  fetch?: typeof fetch;
+  logger?: Logger;
+  /** Seconds since the epoch, for relative times; injectable for tests. */
+  now?: () => number;
+};
+type CreatedServer = {
+  server: McpServer;
+  client: LokiClient;
+  ctx: ToolContext;
+};
+export declare const createServer: (opts: CreateServerOptions) => CreatedServer;
+export declare class LokiApiError extends Error {
+  readonly name: string;
+  /** HTTP status, or 0 when no response arrived at all (DNS, TLS, timeout). */
+  readonly status: number;
+  /**
+   * What to do about it, kept separate from `message`: the message says what
+   * happened, the remedy is the half a model should act on, and fail() lifts it
+   * to a top-level field so it is not buried inside the upstream text.
+   */
+  readonly remedy: string | undefined;
+  readonly errors: unknown;
+  constructor(message: string, opts: {
+    status: number;
+    remedy?: string;
+    errors?: unknown;
+  });
+}
+export type { Config, CreateServerOptions, CreatedServer, Identity, Limits, Logger, LokiClientOptions, LokiResult, Params, Tenant, ToolContext };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/config.ts","../src/client/auth.ts","../src/client/loki.ts","../src/client/identity.ts","../src/tools/index.ts","../src/server.ts","../src/client/errors.ts"],"mappings":";;cAEM,cAAY,EAAA;;;;;;;;;;GA+BP,EAAA,KAAA;KAEC,SAAS,EAAE,aAAa;KAExB;;;;;qBA4CC,aAAU,MAAS,OAAO,eAA2B;qBA6DrD,WAAQ,QAAY,WAAS;;qBAI7B,eAAY,QAAY;KAGzB;EAAW;EAAgB;;;;;;;;;;;;;qBAa1B,gBAAa,QAAY,WAAS;;qBAkBlC,oBAAiB,QAAY;KClL9B;EACV,UAAU;EACV,SAAS;EACT,UAAU;;;;;;;;;qBAUC,cAAW,QAAY,WAAS;;KCSjC,SAAS;KAET,WAAW;EAAO,MAAM;EAAG;;KAuG3B;EACV;EACA,SAAS;EACT;EACA;EACA;EACA,eAAe;EACf,SAAS;;qBAGE;WACF;WACA;mBACQ;mBACA;mBACA;mBACA;mBACA;EAEjB,YAAY,MAAM;EAUZ,IAAI,aACR,cACA,SAAS,QACT,UAAU,yBACT,QAAQ,WAAW;;EAKhB,KAAK,aACT,cACA,QAAQ,QACR,UAAU,yBACT,QAAQ,WAAW;EAQhB,QAAQ,aACZ,wBACA,cACA;IAAQ,SAAS;IAAQ,OAAO;IAAQ,UAAU;MACjD,QAAQ,WAAW;;KC7KZ;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;KAGU;EACV;EACA;EACA,SAAS;;EAET;;qBAmCW,gBAAa,QAAkB,eAAa,QAAQ;KCnDrD;EACV,QAAQ;EACR;;EAEA,QAAQ;;;;;;EAMR;IAAa;;;EAEb,gBAAgB,QAAQ;;EAExB;;qBAGW,oBAAiB,QACpB,YAAU,QACV,QAAM,yBACS,uBAEtB;;;;;;qBAyBU,gBAAa,QAAY,WAAS,QAAU,YAAU,KAAO;qBCpD7D;qBACA;qBACA;KAED;EACV,QAAQ;EACR,eAAe;EACf,SAAS;;EAET;;KAGU;EACV,QAAQ;EACR,QAAQ;EACR,KAAK;;qBAGM,eAAY,MAAU,wBAAsB;qBC1B5C,qBAAqB;WAEd;;WAET;;;;;;WAMA;WACA;EAET,YAAY,iBAAiB;IAAQ;IAAgB;IAAiB"}

package/dist/index.js

@@ -0,0 +1 @@
+export { u as LokiApiError, l as LokiClient, t as SERVER_NAME, n as SERVER_VERSION, r as USER_AGENT, d as authHeaders, f as authMode, i as createServer, a as createToolContext, c as fetchIdentity, p as isConfigured, m as loadConfig, o as registerTools, h as resolveTenant, g as setupInstructions } from "./server-B2TOeJ3P.js";