@jongleberry/atel 0.0.0

package/dist/client/append.mjs

@@ -0,0 +1,18 @@
+import { requestJson } from './http.mjs';
+const JSON_HEADERS = { 'content-type': 'application/json' };
+/** Posts a single telemetry entry. `POST /telemetry` echoes back the created entry. */
+export async function appendEntry(config, input) {
+    return requestJson(config, '/telemetry', {
+        method: 'POST',
+        headers: JSON_HEADERS,
+        body: JSON.stringify(input),
+    });
+}
+/** Posts a batch of telemetry entries. `POST /telemetry` echoes back the created entries. */
+export async function appendEntriesBatch(config, inputs) {
+    return requestJson(config, '/telemetry', {
+        method: 'POST',
+        headers: JSON_HEADERS,
+        body: JSON.stringify(inputs),
+    });
+}

package/dist/client/auth.d.mts

@@ -0,0 +1,26 @@
+import type { CredentialCreated, CredentialSummary } from './types.mjs';
+export interface AuthOptions {
+    baseUrl: string;
+    /** Admin token (`atl_admin_<name>_<secret>`) — never a telemetry token. */
+    adminToken: string;
+}
+/**
+ * Credential (tenant) management — admin-only. Never used by the MCP
+ * server; wired up for the CLI's `credentials` subcommands only.
+ */
+export declare class Auth {
+    #private;
+    constructor(options: AuthOptions);
+    /** Creates a new telemetry credential. The token is returned once. */
+    createCredentials(input: {
+        name: string;
+    }): Promise<CredentialCreated>;
+    /** Lists known credentials (never includes tokens). */
+    listCredentials(): Promise<CredentialSummary[]>;
+    /** Deletes a credential by id or by name. */
+    deleteCredentials(selector: {
+        id: string;
+    } | {
+        name: string;
+    }): Promise<void>;
+}

package/dist/client/auth.mjs

@@ -0,0 +1,23 @@
+import { createCredential, deleteCredential, listCredentials } from './credentials.mjs';
+/**
+ * Credential (tenant) management — admin-only. Never used by the MCP
+ * server; wired up for the CLI's `credentials` subcommands only.
+ */
+export class Auth {
+    #config;
+    constructor(options) {
+        this.#config = { baseUrl: options.baseUrl, token: options.adminToken };
+    }
+    /** Creates a new telemetry credential. The token is returned once. */
+    async createCredentials(input) {
+        return createCredential(this.#config, input);
+    }
+    /** Lists known credentials (never includes tokens). */
+    async listCredentials() {
+        return listCredentials(this.#config);
+    }
+    /** Deletes a credential by id or by name. */
+    async deleteCredentials(selector) {
+        return deleteCredential(this.#config, selector);
+    }
+}

package/dist/client/credentials.d.mts

@@ -0,0 +1,13 @@
+import type { ClientConfig, CredentialCreated, CredentialSummary } from './types.mjs';
+/** `POST /credentials` (admin-only) — creates a telemetry credential. The token is shown once. */
+export declare function createCredential(config: ClientConfig, input: {
+    name: string;
+}): Promise<CredentialCreated>;
+/** `GET /credentials` (admin-only) — lists credentials; never includes tokens. */
+export declare function listCredentials(config: ClientConfig): Promise<CredentialSummary[]>;
+/** `DELETE /credentials?id=` or `?name=` (admin-only). */
+export declare function deleteCredential(config: ClientConfig, selector: {
+    id: string;
+} | {
+    name: string;
+}): Promise<void>;

package/dist/client/credentials.mjs

@@ -0,0 +1,19 @@
+import { rawRequest, requestJson } from './http.mjs';
+/** `POST /credentials` (admin-only) — creates a telemetry credential. The token is shown once. */
+export async function createCredential(config, input) {
+    return requestJson(config, '/credentials', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(input),
+    });
+}
+/** `GET /credentials` (admin-only) — lists credentials; never includes tokens. */
+export async function listCredentials(config) {
+    return requestJson(config, '/credentials', { method: 'GET' });
+}
+/** `DELETE /credentials?id=` or `?name=` (admin-only). */
+export async function deleteCredential(config, selector) {
+    const query = 'id' in selector ? { id: selector.id } : { name: selector.name };
+    const response = await rawRequest(config, '/credentials', { method: 'DELETE', query });
+    await response.text();
+}

package/dist/client/errors.d.mts

@@ -0,0 +1,8 @@
+/** Thrown for any non-2xx response from the atel HTTP API. */
+export declare class AtelError extends Error {
+    /** HTTP status code of the failed response. */
+    readonly status: number;
+    /** Parsed error body — JSON if the response was JSON, raw text otherwise. */
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}

package/dist/client/errors.mjs

@@ -0,0 +1,13 @@
+/** Thrown for any non-2xx response from the atel HTTP API. */
+export class AtelError extends Error {
+    /** HTTP status code of the failed response. */
+    status;
+    /** Parsed error body — JSON if the response was JSON, raw text otherwise. */
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.name = 'AtelError';
+        this.status = status;
+        this.body = body;
+    }
+}

package/dist/client/http.d.mts

@@ -0,0 +1,22 @@
+import type { ClientConfig, GetRawQuery, TelemetryWireFormat } from './types.mjs';
+/** Query params as they go on the wire — every value is a string. */
+type WireQuery = Record<string, string>;
+/** Converts a typed `GET /telemetry` query into wire-format string params. */
+export declare function buildTelemetriesQuery(query: GetRawQuery): WireQuery;
+/** The `Accept` header that matches a given wire format. */
+export declare function acceptHeaderFor(format: TelemetryWireFormat): string;
+interface RequestOptions {
+    method: string;
+    headers?: Record<string, string>;
+    body?: string;
+    query?: WireQuery;
+}
+/**
+ * Issues an authenticated HTTP request and returns the raw `Response`,
+ * throwing `AtelError` on any non-2xx status. Callers that need the
+ * body streamed (not buffered) should read `response.body` directly.
+ */
+export declare function rawRequest(config: ClientConfig, path: string, options: RequestOptions): Promise<Response>;
+/** Issues an authenticated HTTP request and parses the response body as JSON. */
+export declare function requestJson<T>(config: ClientConfig, path: string, options: RequestOptions): Promise<T>;
+export {};

package/dist/client/http.mjs

@@ -0,0 +1,66 @@
+import { AtelError } from './errors.mjs';
+/** Converts a typed `GET /telemetry` query into wire-format string params. */
+export function buildTelemetriesQuery(query) {
+    const wire = {};
+    if (query.sessionId !== undefined)
+        wire.sessionId = query.sessionId;
+    if (query.agent !== undefined)
+        wire.agent = query.agent;
+    if (query.archived !== undefined)
+        wire.archived = String(query.archived);
+    if (query.format !== undefined)
+        wire.format = query.format;
+    return wire;
+}
+const ACCEPT_HEADERS = {
+    json: 'application/json',
+    jsonl: 'application/x-ndjson',
+    markdown: 'text/markdown',
+};
+/** The `Accept` header that matches a given wire format. */
+export function acceptHeaderFor(format) {
+    return ACCEPT_HEADERS[format];
+}
+function buildUrl(baseUrl, path, query) {
+    const base = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+    const url = new URL(path.replace(/^\//, ''), base);
+    for (const [key, value] of Object.entries(query)) {
+        url.searchParams.set(key, value);
+    }
+    return url;
+}
+async function parseErrorBody(response) {
+    const text = await response.text();
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+/**
+ * Issues an authenticated HTTP request and returns the raw `Response`,
+ * throwing `AtelError` on any non-2xx status. Callers that need the
+ * body streamed (not buffered) should read `response.body` directly.
+ */
+export async function rawRequest(config, path, options) {
+    const url = buildUrl(config.baseUrl, path, options.query ?? {});
+    const headers = new Headers(options.headers);
+    headers.set('authorization', `Bearer ${config.token}`);
+    const init = { method: options.method, headers };
+    if (options.body !== undefined)
+        init.body = options.body;
+    const response = await fetch(url, init);
+    if (!response.ok) {
+        const body = await parseErrorBody(response);
+        throw new AtelError(`atel request failed: ${options.method} ${path} -> ${response.status}`, response.status, body);
+    }
+    return response;
+}
+/** Issues an authenticated HTTP request and parses the response body as JSON. */
+export async function requestJson(config, path, options) {
+    const response = await rawRequest(config, path, options);
+    return (await response.json());
+}

package/dist/client/journal.d.mts

@@ -0,0 +1,24 @@
+import type { GetEntriesQuery, TelemetryEntry } from './types.mjs';
+export interface TelemetryOptions {
+    baseUrl: string;
+    token: string;
+    /** Explicit session id; falls back through `resolveSessionId` if omitted. */
+    sessionId?: string;
+    /** Agent identifier attached to every entry. Defaults to `'claude-code'`. */
+    agent?: string;
+}
+export type TelemetryGetOptions = Omit<GetEntriesQuery, 'sessionId' | 'agent'>;
+/**
+ * A telemetry stream bound to one session + agent — the ergonomic entry
+ * point for "record what I'm doing, then read it back later."
+ */
+export declare class Telemetry {
+    #private;
+    readonly sessionId: string;
+    readonly agent: string;
+    constructor(options: TelemetryOptions);
+    /** Appends one unstructured entry to this session's telemetry stream. */
+    append(data: Record<string, unknown>): Promise<TelemetryEntry>;
+    /** Reads this session's telemetry back, streaming entries as they arrive. */
+    get(options?: TelemetryGetOptions): AsyncIterable<TelemetryEntry>;
+}

package/dist/client/journal.mjs

@@ -0,0 +1,35 @@
+import { appendEntry } from './append.mjs';
+import { streamEntries } from './stream.mjs';
+import { resolveSessionId } from '../session.mjs';
+const DEFAULT_AGENT = 'claude-code';
+/**
+ * A telemetry stream bound to one session + agent — the ergonomic entry
+ * point for "record what I'm doing, then read it back later."
+ */
+export class Telemetry {
+    sessionId;
+    agent;
+    #config;
+    constructor(options) {
+        this.#config = { baseUrl: options.baseUrl, token: options.token };
+        this.sessionId = resolveSessionId(options.sessionId);
+        this.agent = options.agent ?? DEFAULT_AGENT;
+    }
+    /** Appends one unstructured entry to this session's telemetry stream. */
+    async append(data) {
+        return appendEntry(this.#config, {
+            sessionId: this.sessionId,
+            agent: this.agent,
+            data,
+        });
+    }
+    /** Reads this session's telemetry back, streaming entries as they arrive. */
+    get(options = {}) {
+        const query = { sessionId: this.sessionId, agent: this.agent };
+        if (options.archived !== undefined)
+            query.archived = options.archived;
+        if (options.format !== undefined)
+            query.format = options.format;
+        return streamEntries(this.#config, query);
+    }
+}

package/dist/client/journals.d.mts

@@ -0,0 +1,18 @@
+import type { AppendInput, ClientConfig, GetEntriesQuery, PatchOp, TelemetryEntry } from './types.mjs';
+/**
+ * Cross-session telemetry operations — batch append, filtered reads across
+ * sessions/agents, and archive/data patches. Use this instead of
+ * `Telemetry` when you're not bound to one session (e.g. a distill pass
+ * over a credential's whole history).
+ */
+export declare class Telemetries {
+    #private;
+    constructor(options: ClientConfig);
+    /** Appends one entry, or a batch — mirrors what `POST /telemetry` accepts. */
+    append(input: AppendInput): Promise<TelemetryEntry>;
+    append(input: AppendInput[]): Promise<TelemetryEntry[]>;
+    /** Reads entries across sessions/agents, streaming as they arrive. */
+    get(query?: GetEntriesQuery): AsyncIterable<TelemetryEntry>;
+    /** Batch-patches entries by id; `data` is a shallow merge, not a replace. */
+    patch(patches: PatchOp[]): Promise<TelemetryEntry[]>;
+}

package/dist/client/journals.mjs

@@ -0,0 +1,28 @@
+import { appendEntry, appendEntriesBatch } from './append.mjs';
+import { patchEntries } from './patch.mjs';
+import { streamEntries } from './stream.mjs';
+/**
+ * Cross-session telemetry operations — batch append, filtered reads across
+ * sessions/agents, and archive/data patches. Use this instead of
+ * `Telemetry` when you're not bound to one session (e.g. a distill pass
+ * over a credential's whole history).
+ */
+export class Telemetries {
+    #config;
+    constructor(options) {
+        this.#config = options;
+    }
+    append(input) {
+        return Array.isArray(input)
+            ? appendEntriesBatch(this.#config, input)
+            : appendEntry(this.#config, input);
+    }
+    /** Reads entries across sessions/agents, streaming as they arrive. */
+    get(query = {}) {
+        return streamEntries(this.#config, query);
+    }
+    /** Batch-patches entries by id; `data` is a shallow merge, not a replace. */
+    async patch(patches) {
+        return patchEntries(this.#config, patches);
+    }
+}

package/dist/client/patch.d.mts

@@ -0,0 +1,6 @@
+import type { ClientConfig, PatchOp, TelemetryEntry } from './types.mjs';
+/**
+ * Batch-patches telemetry entries. `data` is a shallow merge into each
+ * entry's existing `data` blob, not a replace.
+ */
+export declare function patchEntries(config: ClientConfig, patches: PatchOp[]): Promise<TelemetryEntry[]>;

package/dist/client/patch.mjs

@@ -0,0 +1,12 @@
+import { requestJson } from './http.mjs';
+/**
+ * Batch-patches telemetry entries. `data` is a shallow merge into each
+ * entry's existing `data` blob, not a replace.
+ */
+export async function patchEntries(config, patches) {
+    return requestJson(config, '/telemetry', {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(patches),
+    });
+}

package/dist/client/stream.d.mts

@@ -0,0 +1,30 @@
+import type { ClientConfig, GetEntriesQuery, GetRawQuery, TelemetryEntry } from './types.mjs';
+/**
+ * Issues `GET /telemetry` and returns the raw `Response`, without reading
+ * the body. Used both for parsed-entry reads (below) and for the CLI's raw
+ * passthrough of whatever wire format the user asked for.
+ */
+export declare function fetchTelemetriesRaw(config: ClientConfig, query: GetRawQuery): Promise<Response>;
+/**
+ * Parses a `GET /telemetry` response body as newline-delimited JSON,
+ * genuinely incrementally: each line is parsed and yielded as soon as it
+ * has fully arrived, via the underlying `ReadableStream` reader — not after
+ * buffering the whole response.
+ */
+export declare function parseNdjsonStream(response: Response): AsyncGenerator<TelemetryEntry>;
+/**
+ * Parses a `GET /telemetry` response body as a single JSON array. This
+ * cannot be genuinely incremental — a JSON array isn't a valid JSON
+ * document until its closing `]` arrives, so this buffers the full body
+ * before yielding anything. Prefer `format: 'jsonl'` (the default) for real
+ * incremental delivery; this path exists for parity with the server's
+ * default wire format.
+ */
+export declare function parseJsonArrayBuffered(response: Response): AsyncGenerator<TelemetryEntry>;
+/**
+ * Reads `GET /telemetry` as parsed, structured entries. Always requests
+ * `jsonl` on the wire by default (true incremental parsing); pass
+ * `format: 'json'` to match the server's default array format instead, at
+ * the cost of buffering the full response (see `parseJsonArrayBuffered`).
+ */
+export declare function streamEntries(config: ClientConfig, query?: GetEntriesQuery): AsyncGenerator<TelemetryEntry>;

package/dist/client/stream.mjs

@@ -0,0 +1,90 @@
+import { acceptHeaderFor, buildTelemetriesQuery, rawRequest } from './http.mjs';
+/**
+ * Issues `GET /telemetry` and returns the raw `Response`, without reading
+ * the body. Used both for parsed-entry reads (below) and for the CLI's raw
+ * passthrough of whatever wire format the user asked for.
+ */
+export async function fetchTelemetriesRaw(config, query) {
+    const format = query.format ?? 'json';
+    return rawRequest(config, '/telemetry', {
+        method: 'GET',
+        headers: { accept: acceptHeaderFor(format) },
+        query: buildTelemetriesQuery(query),
+    });
+}
+/**
+ * Parses a `GET /telemetry` response body as newline-delimited JSON,
+ * genuinely incrementally: each line is parsed and yielded as soon as it
+ * has fully arrived, via the underlying `ReadableStream` reader — not after
+ * buffering the whole response.
+ */
+export async function* parseNdjsonStream(response) {
+    if (!response.body)
+        return;
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (value) {
+                buffer += decoder.decode(value, { stream: true });
+                let newlineIndex = buffer.indexOf('\n');
+                while (newlineIndex !== -1) {
+                    const line = buffer.slice(0, newlineIndex).trim();
+                    buffer = buffer.slice(newlineIndex + 1);
+                    if (line.length > 0)
+                        yield JSON.parse(line);
+                    newlineIndex = buffer.indexOf('\n');
+                }
+            }
+            if (done)
+                break;
+        }
+        const trailing = buffer.trim();
+        if (trailing.length > 0)
+            yield JSON.parse(trailing);
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+/**
+ * Parses a `GET /telemetry` response body as a single JSON array. This
+ * cannot be genuinely incremental — a JSON array isn't a valid JSON
+ * document until its closing `]` arrives, so this buffers the full body
+ * before yielding anything. Prefer `format: 'jsonl'` (the default) for real
+ * incremental delivery; this path exists for parity with the server's
+ * default wire format.
+ */
+export async function* parseJsonArrayBuffered(response) {
+    const text = (await response.text()).trim();
+    if (text.length === 0)
+        return;
+    const entries = JSON.parse(text);
+    for (const entry of entries)
+        yield entry;
+}
+/**
+ * Reads `GET /telemetry` as parsed, structured entries. Always requests
+ * `jsonl` on the wire by default (true incremental parsing); pass
+ * `format: 'json'` to match the server's default array format instead, at
+ * the cost of buffering the full response (see `parseJsonArrayBuffered`).
+ */
+export async function* streamEntries(config, query = {}) {
+    const format = query.format ?? 'jsonl';
+    const wireQuery = { format };
+    if (query.sessionId !== undefined)
+        wireQuery.sessionId = query.sessionId;
+    if (query.agent !== undefined)
+        wireQuery.agent = query.agent;
+    if (query.archived !== undefined)
+        wireQuery.archived = query.archived;
+    const response = await fetchTelemetriesRaw(config, wireQuery);
+    if (format === 'jsonl') {
+        yield* parseNdjsonStream(response);
+    }
+    else {
+        yield* parseJsonArrayBuffered(response);
+    }
+}

package/dist/client/types.d.mts

@@ -0,0 +1,65 @@
+/**
+ * Shared wire types for the atel HTTP client.
+ *
+ * These mirror the server's documented contract (see the plan doc / server
+ * `packages/server/src/core/handle-request.mts`) but are intentionally
+ * decoupled from it — this package must never import from `packages/server`.
+ */
+/** Config needed to reach the server: a base URL and a bearer token. */
+export interface ClientConfig {
+    baseUrl: string;
+    token: string;
+}
+/** A single telemetry entry as returned by the server. */
+export interface TelemetryEntry {
+    id: string;
+    sessionId: string;
+    agent: string;
+    createdAt: string;
+    archived: boolean;
+    data: Record<string, unknown>;
+}
+/** Body accepted by `POST /telemetry` for a single entry. */
+export interface AppendInput {
+    sessionId: string;
+    agent: string;
+    data: Record<string, unknown>;
+}
+/**
+ * Wire format for `GET /telemetry`. `'markdown'` is only meaningful for raw
+ * (unparsed) reads — see `client/stream.mts` for why entry-returning reads
+ * are restricted to `'json' | 'jsonl'`.
+ */
+export type TelemetryWireFormat = 'json' | 'jsonl' | 'markdown';
+/** Format restricted to values that parse into structured entries. */
+export type TelemetryEntryFormat = Extract<TelemetryWireFormat, 'json' | 'jsonl'>;
+/** Query params accepted by `GET /telemetry` when reading parsed entries. */
+export interface GetEntriesQuery {
+    sessionId?: string;
+    agent?: string;
+    archived?: boolean;
+    format?: TelemetryEntryFormat;
+}
+/** Query params accepted by `GET /telemetry` for a raw (unparsed) read. */
+export interface GetRawQuery {
+    sessionId?: string;
+    agent?: string;
+    archived?: boolean;
+    format?: TelemetryWireFormat;
+}
+/** One patch operation accepted by `PATCH /telemetry`. `data` is a shallow merge. */
+export interface PatchOp {
+    id: string;
+    archived?: boolean;
+    data?: Record<string, unknown>;
+}
+/** A telemetry or admin credential, as listed by `GET /credentials`. */
+export interface CredentialSummary {
+    id: string;
+    name: string;
+    createdAt: string;
+}
+/** The one-time response from `POST /credentials`, including the secret token. */
+export interface CredentialCreated extends CredentialSummary {
+    token: string;
+}

package/dist/client/types.mjs

@@ -0,0 +1,8 @@
+/**
+ * Shared wire types for the atel HTTP client.
+ *
+ * These mirror the server's documented contract (see the plan doc / server
+ * `packages/server/src/core/handle-request.mts`) but are intentionally
+ * decoupled from it — this package must never import from `packages/server`.
+ */
+export {};

package/dist/format-error.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Formats any thrown value as a single-line, human-readable message — never
+ * a raw stack trace. Shared by the CLI (stderr) and the MCP server (tool
+ * error content), since a caller can throw anything in JS, not just `Error`.
+ */
+export declare function formatError(err: unknown): string;

package/dist/format-error.mjs

@@ -0,0 +1,15 @@
+import { AtelError } from './client/errors.mjs';
+/**
+ * Formats any thrown value as a single-line, human-readable message — never
+ * a raw stack trace. Shared by the CLI (stderr) and the MCP server (tool
+ * error content), since a caller can throw anything in JS, not just `Error`.
+ */
+export function formatError(err) {
+    if (err instanceof AtelError) {
+        const bodyText = err.body === undefined ? '' : ` ${JSON.stringify(err.body)}`;
+        return `${err.message}${bodyText}`;
+    }
+    if (err instanceof Error)
+        return err.message;
+    return String(err);
+}

package/dist/index.d.mts

@@ -0,0 +1,20 @@
+/**
+ * Public API of `@jongleberry/atel`: a thin `fetch`-based client for the
+ * atel HTTP service.
+ *
+ * - `Telemetry` — append + read, bound to one session + agent.
+ * - `Telemetries` — batch append/read/patch across sessions.
+ * - `Auth` — admin-only credential management.
+ *
+ * This module must never import `@aws-sdk/*` or anything from
+ * `packages/server` (enforced by `.dependency-cruiser.cjs`).
+ */
+export { Auth } from './client/auth.mjs';
+export type { AuthOptions } from './client/auth.mjs';
+export { AtelError } from './client/errors.mjs';
+export { Telemetry } from './client/journal.mjs';
+export type { TelemetryGetOptions, TelemetryOptions } from './client/journal.mjs';
+export { Telemetries } from './client/journals.mjs';
+export type { AppendInput, ClientConfig, CredentialCreated, CredentialSummary, GetEntriesQuery, GetRawQuery, PatchOp, TelemetryEntry, TelemetryEntryFormat, TelemetryWireFormat, } from './client/types.mjs';
+export { resolveSessionId } from './session.mjs';
+export type { ResolveSessionIdOptions } from './session.mjs';

package/dist/index.mjs

@@ -0,0 +1,16 @@
+/**
+ * Public API of `@jongleberry/atel`: a thin `fetch`-based client for the
+ * atel HTTP service.
+ *
+ * - `Telemetry` — append + read, bound to one session + agent.
+ * - `Telemetries` — batch append/read/patch across sessions.
+ * - `Auth` — admin-only credential management.
+ *
+ * This module must never import `@aws-sdk/*` or anything from
+ * `packages/server` (enforced by `.dependency-cruiser.cjs`).
+ */
+export { Auth } from './client/auth.mjs';
+export { AtelError } from './client/errors.mjs';
+export { Telemetry } from './client/journal.mjs';
+export { Telemetries } from './client/journals.mjs';
+export { resolveSessionId } from './session.mjs';

package/dist/mcp/dispatch.d.mts

@@ -0,0 +1,3 @@
+import type { ClientConfig } from '../client/types.mjs';
+/** Routes a `tools/call` request to the matching handler by tool name. */
+export declare function dispatchTool(name: string, args: Record<string, unknown>, config: ClientConfig): Promise<unknown>;

package/dist/mcp/dispatch.mjs

@@ -0,0 +1,16 @@
+import { handleTelemetryAppend } from './tool-append.mjs';
+import { handleTelemetryGet } from './tool-get.mjs';
+import { handleTelemetryPatch } from './tool-patch.mjs';
+/** Routes a `tools/call` request to the matching handler by tool name. */
+export async function dispatchTool(name, args, config) {
+    switch (name) {
+        case 'telemetry_append':
+            return handleTelemetryAppend(args, config);
+        case 'telemetry_get':
+            return handleTelemetryGet(args, config);
+        case 'telemetry_patch':
+            return handleTelemetryPatch(args, config);
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}

package/dist/mcp/schemas.d.mts

@@ -0,0 +1,2 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const TELEMETRY_TOOLS: Tool[];