@paneui/core 0.0.5 → 0.0.7

package/dist/client.js

@@ -121,10 +121,11 @@ export class PaneClient {
             docsUrl: err?.docs_url,
         });
     }
-    /** POST /v1/sessions — create a session. */
+    /** POST /v1/surfaces — create a surface. */
     async createSession(req) {
-        const r = await this.call("POST", "/v1/sessions", {
-            artifact: req.artifact,
+        const r = await this.call("POST", "/v1/surfaces", {
+            template: req.template,
+            title: req.title,
             input_data: req.input_data,
             participants: req.participants,
             ttl: req.ttl,
@@ -135,19 +136,19 @@ export class PaneClient {
             this.fail(r);
         return this.asObject(r);
     }
-    /** GET /v1/sessions/:id — non-blocking session metadata. */
-    async getSession(sessionId) {
-        const r = await this.call("GET", `/v1/sessions/${encodeURIComponent(sessionId)}`);
+    /** GET /v1/surfaces/:id — non-blocking surface metadata. */
+    async getSession(surfaceId) {
+        const r = await this.call("GET", `/v1/surfaces/${encodeURIComponent(surfaceId)}`);
         if (!r.ok)
             this.fail(r);
         return this.asObject(r);
     }
     /**
-     * GET /v1/sessions/:id/events — fetch the event log.
+     * GET /v1/surfaces/:id/events — fetch the event log.
      * `since` is an opaque cursor; `waitSeconds` enables the relay long-poll
      * (0 = non-blocking, capped at 30 by the relay).
      */
-    async getEvents(sessionId, opts = {}) {
+    async getEvents(surfaceId, opts = {}) {
         const q = new URLSearchParams();
         if (opts.since != null && opts.since !== "")
             q.set("since", opts.since);
@@ -155,14 +156,14 @@ export class PaneClient {
             q.set("wait", String(Math.floor(opts.waitSeconds)));
         }
         const qs = q.toString();
-        const r = await this.call("GET", `/v1/sessions/${encodeURIComponent(sessionId)}/events${qs ? "?" + qs : ""}`);
+        const r = await this.call("GET", `/v1/surfaces/${encodeURIComponent(surfaceId)}/events${qs ? "?" + qs : ""}`);
         if (!r.ok)
             this.fail(r);
         return this.asObject(r);
     }
-    /** POST /v1/sessions/:id/events — append an agent event. */
-    async sendEvent(sessionId, ev) {
-        const r = await this.call("POST", `/v1/sessions/${encodeURIComponent(sessionId)}/events`, {
+    /** POST /v1/surfaces/:id/events — append an agent event. */
+    async sendEvent(surfaceId, ev) {
+        const r = await this.call("POST", `/v1/surfaces/${encodeURIComponent(surfaceId)}/events`, {
             type: ev.type,
             data: ev.data,
             causation_id: ev.causationId,
@@ -174,11 +175,11 @@ export class PaneClient {
         return { event: body.event, deduped: body.deduped ?? false };
     }
     /**
-     * POST /v1/artifacts — create a named, reusable artifact and its v1 content.
-     * Returns the new `artifact_id` and `version` (1).
+     * POST /v1/templates — create a named, reusable template and its v1 content.
+     * Returns the new `template_id` and `version` (1).
      */
     async createArtifact(req) {
-        const r = await this.call("POST", "/v1/artifacts", {
+        const r = await this.call("POST", "/v1/templates", {
             name: req.name,
             slug: req.slug,
             description: req.description,
@@ -193,12 +194,12 @@ export class PaneClient {
         return this.asObject(r);
     }
     /**
-     * POST /v1/artifacts/:id/versions — append a new immutable version to an
-     * existing artifact. `idOrSlug` accepts the artifact id or its slug.
+     * POST /v1/templates/:id/versions — append a new immutable version to an
+     * existing template. `idOrSlug` accepts the template id or its slug.
      * Returns the new `version` number.
      */
     async createArtifactVersion(idOrSlug, req) {
-        const r = await this.call("POST", `/v1/artifacts/${encodeURIComponent(idOrSlug)}/versions`, {
+        const r = await this.call("POST", `/v1/templates/${encodeURIComponent(idOrSlug)}/versions`, {
             source: req.source,
             type: req.type,
             event_schema: req.event_schema,
@@ -209,11 +210,11 @@ export class PaneClient {
         return this.asObject(r);
     }
     /**
-     * PATCH /v1/artifacts/:id — update head metadata (name / slug / description /
+     * PATCH /v1/templates/:id — update head metadata (name / slug / description /
      * tags); never the content. Returns the updated lean summary.
      */
     async updateArtifact(idOrSlug, metadata) {
-        const r = await this.call("PATCH", `/v1/artifacts/${encodeURIComponent(idOrSlug)}`, {
+        const r = await this.call("PATCH", `/v1/templates/${encodeURIComponent(idOrSlug)}`, {
             name: metadata.name,
             slug: metadata.slug,
             description: metadata.description,
@@ -224,33 +225,33 @@ export class PaneClient {
         return this.asObject(r);
     }
     /**
-     * GET /v1/artifacts?q=... — search/list the agent's named artifacts. The
-     * response is lean (no `source` blob), ranked by `last_used_at`. Omit `query`
-     * to list every named artifact.
+     * GET /v1/templates?q=... — search/list the agent's named templates. The
+     * response is lean (no `source` attachment), ranked by `last_used_at`. Omit `query`
+     * to list every named template.
      */
     async searchArtifacts(query) {
         const qs = query != null && query !== "" ? "?q=" + encodeURIComponent(query) : "";
-        const r = await this.call("GET", `/v1/artifacts${qs}`);
+        const r = await this.call("GET", `/v1/templates${qs}`);
         if (!r.ok)
             this.fail(r);
-        return this.asObject(r).artifacts;
+        return this.asObject(r).templates;
     }
     /**
-     * GET /v1/artifacts/:id — fetch a full artifact (head metadata + version
-     * list). `idOrSlug` accepts the artifact id or its slug.
+     * GET /v1/templates/:id — fetch a full template (head metadata + version
+     * list). `idOrSlug` accepts the template id or its slug.
      */
     async getArtifact(idOrSlug) {
-        const r = await this.call("GET", `/v1/artifacts/${encodeURIComponent(idOrSlug)}`);
+        const r = await this.call("GET", `/v1/templates/${encodeURIComponent(idOrSlug)}`);
         if (!r.ok)
             this.fail(r);
         return this.asObject(r);
     }
     /**
-     * GET /v1/artifacts/:id/versions/:version — fetch one version's full
+     * GET /v1/templates/:id/versions/:version — fetch one version's full
      * content (HTML, event schema, input schema).
      */
     async getArtifactVersion(idOrSlug, version) {
-        const r = await this.call("GET", `/v1/artifacts/${encodeURIComponent(idOrSlug)}/versions/${encodeURIComponent(String(version))}`);
+        const r = await this.call("GET", `/v1/templates/${encodeURIComponent(idOrSlug)}/versions/${encodeURIComponent(String(version))}`);
         if (!r.ok)
             this.fail(r);
         return this.asObject(r);
@@ -276,10 +277,23 @@ export class PaneClient {
             this.fail(r);
     }
     /**
-     * GET /v1/taste — the calling agent's freeform "taste notes" markdown blob:
+     * POST /v1/agents/claim — bind this agent to a human via a one-shot
+     * claim code the human generated in their settings UI. After a
+     * successful claim the agent's existing API key continues to work,
+     * but the agent (and its surfaces/templates) now belong to the
+     * claiming human. One-way operation — there is no unclaim in v1.
+     */
+    async claimAgent(code) {
+        const r = await this.call("POST", "/v1/agents/claim", { code });
+        if (!r.ok)
+            this.fail(r);
+        return this.asObject(r);
+    }
+    /**
+     * GET /v1/taste — the calling agent's freeform "taste notes" markdown attachment:
      * presentation preferences the agent has picked up from human feedback over
      * time. Returns `{ taste: null, updated_at: null, bytes: 0 }` when the
-     * agent has never written notes. Read this before generating an artifact so
+     * agent has never written notes. Read this before generating an template so
      * the agent applies prior feedback.
      */
     async getTaste() {
@@ -289,7 +303,7 @@ export class PaneClient {
         return this.asObject(r);
     }
     /**
-     * PUT /v1/taste — whole-blob replace of the calling agent's taste notes.
+     * PUT /v1/taste — whole-attachment replace of the calling agent's taste notes.
      * Empty/whitespace-only values are rejected by the relay; callers asking to
      * clear must use {@link clearTaste}. The relay caps the payload at the
      * server's `MAX_TASTE_BYTES` (utf8 bytes).
@@ -319,7 +333,7 @@ export class PaneClient {
         const r = await this.call("POST", "/v1/feedback", {
             type: req.type,
             message: req.message,
-            session_id: req.sessionId,
+            surface_id: req.surfaceId,
         });
         if (!r.ok)
             this.fail(r);
@@ -342,24 +356,300 @@ export class PaneClient {
         return this.asObject(r);
     }
     /**
-     * DELETE /v1/sessions/:id — close/delete a session. Idempotent on the relay
-     * side (an already-closed session still returns 204 with no body).
+     * GET /v1/surfaces — list the calling agent's surfaces. Default filter is
+     * `status=open` (effective status — respects expiresAt). Response items
+     * carry NO secrets: no participant token plaintext, no callback URL, no
+     * metadata or input_data. Use `participant_id` from the list as the handle
+     * for {@link revokeParticipant}; use {@link mintParticipant} to issue a
+     * fresh URL when the original was lost.
+     */
+    async listSessions(opts = {}) {
+        const q = new URLSearchParams();
+        if (opts.status !== undefined)
+            q.set("status", opts.status);
+        if (opts.limit !== undefined)
+            q.set("limit", String(opts.limit));
+        if (opts.cursor !== undefined && opts.cursor !== "")
+            q.set("cursor", opts.cursor);
+        if (opts.template_id !== undefined && opts.template_id !== "")
+            q.set("template_id", opts.template_id);
+        const qs = q.toString();
+        const r = await this.call("GET", `/v1/surfaces${qs ? "?" + qs : ""}`);
+        if (!r.ok)
+            this.fail(r);
+        return this.asObject(r);
+    }
+    /**
+     * GET /v1/surfaces/:id/participants — list every participant on one
+     * surface (active and revoked). Bounded by MAX_PARTICIPANTS_PER_SESSION
+     * on the relay, so the full list is returned with no pagination.
+     * Use this to find the `participant_id` you need to pass to
+     * {@link revokeParticipant}, or to audit revoked rows.
+     */
+    async listParticipants(surfaceId) {
+        const r = await this.call("GET", `/v1/surfaces/${encodeURIComponent(surfaceId)}/participants`);
+        if (!r.ok)
+            this.fail(r);
+        return this.asObject(r);
+    }
+    /**
+     * POST /v1/surfaces/:id/participants — mint a fresh participant URL for an
+     * existing surface. The one-shot recovery primitive when the original URL
+     * was dropped: the surface keeps its event log, template pin, and created_at.
+     * v1 supports `kind: "human"` only.
+     *
+     * The plaintext token is returned EXACTLY ONCE in the response — the relay
+     * stores only the hash. Save the response (e.g. pipe to a JSONL log) before
+     * delivering the URL to the human.
+     */
+    async mintParticipant(surfaceId, opts = {}) {
+        const r = await this.call("POST", `/v1/surfaces/${encodeURIComponent(surfaceId)}/participants`, { kind: opts.kind ?? "human" });
+        if (!r.ok)
+            this.fail(r);
+        return this.asObject(r);
+    }
+    /**
+     * DELETE /v1/surfaces/:id/participants/:participant_id — revoke a single
+     * participant URL. The surface's other participants (and the agent's own
+     * WebSocket) are untouched. Idempotent: revoking an unknown or already-
+     * revoked participant returns 204. The agent participant cannot be revoked
+     * via this endpoint — use {@link deleteSession} instead.
+     *
+     * Existing WebSocket connections held under the revoked token are NOT
+     * actively kicked in v1; new HTTP and WS connections are refused.
+     */
+    async revokeParticipant(surfaceId, participantId) {
+        const r = await this.call("DELETE", `/v1/surfaces/${encodeURIComponent(surfaceId)}/participants/${encodeURIComponent(participantId)}`);
+        if (!r.ok)
+            this.fail(r);
+    }
+    /**
+     * DELETE /v1/surfaces/:id — close/delete a surface. Idempotent on the relay
+     * side (an already-closed surface still returns 204 with no body).
      */
     async deleteSession(id) {
-        const r = await this.call("DELETE", `/v1/sessions/${encodeURIComponent(id)}`);
+        const r = await this.call("DELETE", `/v1/surfaces/${encodeURIComponent(id)}`);
         if (!r.ok)
             this.fail(r);
     }
     /**
-     * DELETE /v1/artifacts/:id — remove an artifact and (server-side) all its
+     * DELETE /v1/templates/:id — remove an template and (server-side) all its
      * versions. Strict cascade: the relay refuses with 409 conflict if any
-     * session in any state still references one of the artifact's versions —
+     * surface in any state still references one of the template's versions —
      * surface that as a typed PaneApiError so the CLI can render a hint
      * instead of swallowing it.
      */
     async deleteArtifact(idOrSlug) {
-        const r = await this.call("DELETE", `/v1/artifacts/${encodeURIComponent(idOrSlug)}`);
+        const r = await this.call("DELETE", `/v1/templates/${encodeURIComponent(idOrSlug)}`);
+        if (!r.ok)
+            this.fail(r);
+    }
+    // ------------------------------------------------------------------------
+    // Blobs (v0.1.0). Three-scope binary attachments with multipart upload.
+    // See proposal pane#152 for the full design.
+    // ------------------------------------------------------------------------
+    /**
+     * Upload a attachment to the relay. Returns a `AttachmentRef` that can be referenced
+     * in event payloads (the relay's `format: pane-attachment-id` schema vocab
+     * validates the id) or in `pane create --input-data`.
+     *
+     * Scope defaults to "agent" (reusable across the agent's surfaces). For
+     * `scope: "surface"` pass `surfaceId`; for `scope: "template"` pass
+     * `templateId`. The agent must own the referenced surface / template;
+     * cross-tenant attempts return attachment_not_found.
+     *
+     * MIME is inferred from `mime` if supplied; otherwise the relay sniffs
+     * leading bytes and may reject with mime_mismatch / mime_disallowed.
+     *
+     * Backed by the relay's multipart `POST /v1/attachments` (the fallback path).
+     * For large uploads (>1 MB on hosted Azure) call `presignBlob()` +
+     * `confirmBlob()` instead — those use SAS direct-to-storage and don't
+     * stream bytes through the relay.
+     */
+    async uploadBlob(file, opts = {}) {
+        const fd = new FormData();
+        let attachment;
+        if (file instanceof Blob) {
+            attachment = file;
+        }
+        else {
+            // Buffer / Uint8Array path — wrap in a Blob with the declared MIME.
+            // Copy into a freshly allocated Uint8Array so the buffer type
+            // narrows from `ArrayBufferLike` (which includes SharedArrayBuffer)
+            // to `ArrayBuffer` specifically — the Blob constructor accepts only
+            // the latter under @types/node ≥25 + TS ≥5.7's generic narrowing of
+            // Uint8Array<TArrayBuffer>. `new Uint8Array(length)` returns
+            // `Uint8Array<ArrayBuffer>` by construction, satisfying AttachmentPart
+            // without a type cast. The extra copy is one walk over the bytes —
+            // negligible vs the network upload that follows.
+            const src = file instanceof Uint8Array ? file : new Uint8Array(file);
+            const u8 = new Uint8Array(src.byteLength);
+            u8.set(src);
+            attachment = new Blob([u8], {
+                type: opts.mime ?? "application/octet-stream",
+            });
+        }
+        fd.set("file", attachment, opts.filename ?? "attachment");
+        if (opts.scope)
+            fd.set("scope", opts.scope);
+        if (opts.surfaceId)
+            fd.set("surface_id", opts.surfaceId);
+        if (opts.templateId)
+            fd.set("template_id", opts.templateId);
+        if (opts.filename)
+            fd.set("filename", opts.filename);
+        const url = this.base + "/v1/attachments";
+        let res;
+        try {
+            res = await this.fetchImpl(url, {
+                method: "POST",
+                headers: {
+                    authorization: "Bearer " + this.apiKey,
+                    ...(this.cliVersion ? { "x-pane-cli-version": this.cliVersion } : {}),
+                },
+                body: fd,
+            });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            throw new PaneApiError(0, "fetch_error", msg);
+        }
+        const text = await res.text().catch(() => "");
+        let data;
+        try {
+            data = text ? JSON.parse(text) : null;
+        }
+        catch {
+            throw new PaneApiError(res.status, "non_json_response", `relay returned a non-JSON body (status ${res.status})`);
+        }
+        if (!res.ok) {
+            this.fail({ ok: false, status: res.status, data });
+        }
+        return data;
+    }
+    /** GET /v1/attachments/:id — download bytes as an ArrayBuffer. */
+    async downloadBlob(attachmentId) {
+        const url = this.base + "/v1/attachments/" + encodeURIComponent(attachmentId);
+        const res = await this.fetchImpl(url, {
+            method: "GET",
+            headers: {
+                authorization: "Bearer " + this.apiKey,
+                ...(this.cliVersion ? { "x-pane-cli-version": this.cliVersion } : {}),
+            },
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            let data;
+            try {
+                data = text ? JSON.parse(text) : null;
+            }
+            catch {
+                data = null;
+            }
+            this.fail({ ok: false, status: res.status, data });
+        }
+        return res.arrayBuffer();
+    }
+    /**
+     * GET a attachment's metadata only — useful before downloading large attachments, or
+     * for `pane attachment show <id>` which doesn't want the bytes. Returns the full
+     * AttachmentRef (the same shape POST /v1/attachments returns): id, scope, mime, size,
+     * sha256, filename, width, height, status, scope FKs, timestamps.
+     *
+     * Backed by GET /v1/attachments/:id/metadata which serves the JSON AttachmentRef
+     * without streaming the bytes — cheap on the relay and avoids the
+     * encrypt-at-rest decrypt cost when only the metadata is needed.
+     */
+    async getBlob(attachmentId) {
+        const r = await this.call("GET", "/v1/attachments/" + encodeURIComponent(attachmentId) + "/metadata");
         if (!r.ok)
             this.fail(r);
+        return this.asObject(r);
+    }
+    /** DELETE /v1/attachments/:id — soft-delete (idempotent). */
+    async deleteBlob(attachmentId) {
+        const r = await this.call("DELETE", "/v1/attachments/" + encodeURIComponent(attachmentId));
+        if (!r.ok)
+            this.fail(r);
+        return { deleted: true };
+    }
+    /**
+     * Mint a `/b/<token>` capability URL for `attachmentId`. Default TTL is set by
+     * the relay (24h agent, surface-TTL surface, 30d template). `once: true`
+     * tokens self-delete on first GET.
+     */
+    async mintBlobToken(attachmentId, opts = {}) {
+        const r = await this.call("POST", "/v1/attachments/" + encodeURIComponent(attachmentId) + "/tokens", { ttl_seconds: opts.ttlSeconds, once: opts.once });
+        if (!r.ok)
+            this.fail(r);
+        return r.data;
+    }
+    /** Revoke a previously-minted token. Idempotent. */
+    async revokeBlobToken(attachmentId, tokenId) {
+        const r = await this.call("DELETE", "/v1/attachments/" +
+            encodeURIComponent(attachmentId) +
+            "/tokens/" +
+            encodeURIComponent(tokenId));
+        if (!r.ok)
+            this.fail(r);
+        return r.data;
+    }
+    /**
+     * GET /v1/attachments — list YOUR agent's non-deleted attachments (newest first).
+     * Paginated via opaque cursor: when `next_cursor` is non-null, pass it
+     * back as `cursor` on the next call.
+     */
+    async listBlobs(opts = {}) {
+        const params = new URLSearchParams();
+        if (opts.cursor !== undefined)
+            params.set("cursor", opts.cursor);
+        if (opts.limit !== undefined)
+            params.set("limit", String(opts.limit));
+        const qs = params.toString();
+        const r = await this.call("GET", "/v1/attachments" + (qs ? "?" + qs : ""));
+        if (!r.ok)
+            this.fail(r);
+        return r.data;
+    }
+    /**
+     * GET /v1/attachments/:id/tokens — enumerate the capability tokens minted
+     * against one attachment, including revoked rows (for audit). The plaintext
+     * token is NEVER returned — it isn't stored, only its sha256 is.
+     */
+    async listBlobTokens(attachmentId) {
+        const r = await this.call("GET", "/v1/attachments/" + encodeURIComponent(attachmentId) + "/tokens");
+        if (!r.ok)
+            this.fail(r);
+        return r.data;
+    }
+    /**
+     * Issue a presigned PUT URL for direct-to-storage upload. Returns the
+     * upload URL + the attachment_id (already reserved in the relay's DB with
+     * status=pending) + expiry. After PUTting the bytes to the URL, call
+     * `confirmBlob(attachment_id)` to finalise.
+     *
+     * Filesystem backend returns 501 not_implemented — use uploadBlob()
+     * (multipart fallback) instead. Azure backend returns a SAS URL.
+     */
+    async presignBlob(opts) {
+        const r = await this.call("POST", "/v1/attachments/presign", {
+            mime: opts.mime,
+            size: opts.size,
+            sha256: opts.sha256,
+            scope: opts.scope,
+            surface_id: opts.surfaceId,
+            template_id: opts.templateId,
+            filename: opts.filename,
+        });
+        if (!r.ok)
+            this.fail(r);
+        return r.data;
+    }
+    /** Finalise a presigned upload — relay HEADs the bytes, verifies, flips ready. */
+    async confirmBlob(attachmentId) {
+        const r = await this.call("POST", "/v1/attachments/" + encodeURIComponent(attachmentId) + "/confirm");
+        if (!r.ok)
+            this.fail(r);
+        return r.data;
     }
 }

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 export { PaneClient, PaneApiError } from "./client.js";
-export type { ClientOptions, RelayResponse, CreateArtifactRequest, CreateArtifactVersionRequest, PatchArtifactMetadataRequest, } from "./client.js";
+export type { ClientOptions, RelayResponse, CreateArtifactRequest, CreateArtifactVersionRequest, PatchArtifactMetadataRequest, AttachmentRef, UploadBlobOptions, PresignBlobOptions, AttachmentTokenMintResponse, ListBlobsOptions, AttachmentTokenAuditEntry, AttachmentTokenListResponse, } from "./client.js";
 export { openStream } from "./stream.js";
 export type { OpenStreamOptions, StreamHandlers, StreamHandle, } from "./stream.js";
 export { registerAgent } from "./register.js";
 export type { RegisterAgentOptions, RegisterAgentResult } from "./register.js";
-export { artifactSchema, callbackSchema, createSessionSchema, artifactTypeSchema, createArtifactSchema, createArtifactVersionSchema, patchArtifactMetadataSchema, feedbackTypeSchema, submitFeedbackSchema, } from "./schemas.js";
-export type { CreateSessionInput } from "./schemas.js";
+export { artifactSchema, callbackSchema, createSessionSchema, artifactTypeSchema, createArtifactSchema, createArtifactVersionSchema, patchArtifactMetadataSchema, feedbackTypeSchema, submitFeedbackSchema, listSessionsStatusSchema, listSessionsQuerySchema, mintParticipantSchema, } from "./schemas.js";
+export type { CreateSessionInput, ListSessionsStatus, ListSessionsQuery, MintParticipantInput, } from "./schemas.js";
 export { MAX_EVENT_TYPE_LENGTH, MAX_IDEMPOTENCY_KEY_LENGTH, MAX_RESPONSE_SNIPPET_LENGTH, MAX_FRAME_SNIPPET_LENGTH, } from "./limits.js";
-export type { AuthorKind, PaneEvent, Artifact, ArtifactType, ArtifactVersion, ArtifactRecord, ArtifactSummary, CreateArtifactResponse, KeyInfo, TasteInfo, FeedbackType, FeedbackSubmission, FeedbackRecord, FeedbackPage, Callback, CreateSessionRequest, CreateSessionResponse, SessionState, EventsPage, RelayError, } from "./types.js";
+export type { AuthorKind, PaneEvent, Template, TemplateType, TemplateVersion, TemplateRecord, TemplateSummary, CreateArtifactResponse, KeyInfo, TasteInfo, FeedbackType, FeedbackSubmission, FeedbackRecord, FeedbackPage, Callback, CreateSessionRequest, CreateSessionResponse, SurfaceState, EventsPage, ParticipantSummary, ParticipantsList, SurfaceSummary, SurfacesPage, MintParticipantResponse, RelayError, } from "./types.js";

package/dist/index.js

@@ -3,5 +3,5 @@
 export { PaneClient, PaneApiError } from "./client.js";
 export { openStream } from "./stream.js";
 export { registerAgent } from "./register.js";
-export { artifactSchema, callbackSchema, createSessionSchema, artifactTypeSchema, createArtifactSchema, createArtifactVersionSchema, patchArtifactMetadataSchema, feedbackTypeSchema, submitFeedbackSchema, } from "./schemas.js";
+export { artifactSchema, callbackSchema, createSessionSchema, artifactTypeSchema, createArtifactSchema, createArtifactVersionSchema, patchArtifactMetadataSchema, feedbackTypeSchema, submitFeedbackSchema, listSessionsStatusSchema, listSessionsQuerySchema, mintParticipantSchema, } from "./schemas.js";
 export { MAX_EVENT_TYPE_LENGTH, MAX_IDEMPOTENCY_KEY_LENGTH, MAX_RESPONSE_SNIPPET_LENGTH, MAX_FRAME_SNIPPET_LENGTH, } from "./limits.js";