@paneui/core 0.0.6 → 0.0.8

package/dist/client.js

@@ -121,10 +121,10 @@ 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,
@@ -136,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);
@@ -156,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,
@@ -175,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,
@@ -194,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,
@@ -210,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,
@@ -225,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);
@@ -277,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() {
@@ -290,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).
@@ -320,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);
@@ -343,7 +356,7 @@ export class PaneClient {
         return this.asObject(r);
     }
     /**
-     * GET /v1/sessions — list the calling agent's sessions. Default filter is
+     * 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
@@ -358,46 +371,46 @@ export class PaneClient {
             q.set("limit", String(opts.limit));
         if (opts.cursor !== undefined && opts.cursor !== "")
             q.set("cursor", opts.cursor);
-        if (opts.artifact_id !== undefined && opts.artifact_id !== "")
-            q.set("artifact_id", opts.artifact_id);
+        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/sessions${qs ? "?" + qs : ""}`);
+        const r = await this.call("GET", `/v1/surfaces${qs ? "?" + qs : ""}`);
         if (!r.ok)
             this.fail(r);
         return this.asObject(r);
     }
     /**
-     * GET /v1/sessions/:id/participants — list every participant on one
-     * session (active and revoked). Bounded by MAX_PARTICIPANTS_PER_SESSION
+     * 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(sessionId) {
-        const r = await this.call("GET", `/v1/sessions/${encodeURIComponent(sessionId)}/participants`);
+    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/sessions/:id/participants — mint a fresh participant URL for an
-     * existing session. The one-shot recovery primitive when the original URL
-     * was dropped: the session keeps its event log, artifact pin, and created_at.
+     * 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(sessionId, opts = {}) {
-        const r = await this.call("POST", `/v1/sessions/${encodeURIComponent(sessionId)}/participants`, { kind: opts.kind ?? "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/sessions/:id/participants/:participant_id — revoke a single
-     * participant URL. The session's other participants (and the agent's own
+     * 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.
@@ -405,29 +418,29 @@ export class PaneClient {
      * Existing WebSocket connections held under the revoked token are NOT
      * actively kicked in v1; new HTTP and WS connections are refused.
      */
-    async revokeParticipant(sessionId, participantId) {
-        const r = await this.call("DELETE", `/v1/sessions/${encodeURIComponent(sessionId)}/participants/${encodeURIComponent(participantId)}`);
+    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/sessions/:id — close/delete a session. Idempotent on the relay
-     * side (an already-closed session still returns 204 with no body).
+     * 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);
     }
@@ -436,28 +449,28 @@ export class PaneClient {
     // See proposal pane#152 for the full design.
     // ------------------------------------------------------------------------
     /**
-     * Upload a blob to the relay. Returns a `BlobRef` that can be referenced
-     * in event payloads (the relay's `format: pane-blob-id` schema vocab
+     * 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 sessions). For
-     * `scope: "session"` pass `sessionId`; for `scope: "artifact"` pass
-     * `artifactId`. The agent must own the referenced session / artifact;
-     * cross-tenant attempts return blob_not_found.
+     * 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/blobs` (the fallback path).
+     * 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 blob;
+        let attachment;
         if (file instanceof Blob) {
-            blob = file;
+            attachment = file;
         }
         else {
             // Buffer / Uint8Array path — wrap in a Blob with the declared MIME.
@@ -466,26 +479,26 @@ export class PaneClient {
             // 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 BlobPart
+            // `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);
-            blob = new Blob([u8], {
+            attachment = new Blob([u8], {
                 type: opts.mime ?? "application/octet-stream",
             });
         }
-        fd.set("file", blob, opts.filename ?? "blob");
+        fd.set("file", attachment, opts.filename ?? "attachment");
         if (opts.scope)
             fd.set("scope", opts.scope);
-        if (opts.sessionId)
-            fd.set("session_id", opts.sessionId);
-        if (opts.artifactId)
-            fd.set("artifact_id", opts.artifactId);
+        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/blobs";
+        const url = this.base + "/v1/attachments";
         let res;
         try {
             res = await this.fetchImpl(url, {
@@ -514,9 +527,9 @@ export class PaneClient {
         }
         return data;
     }
-    /** GET /v1/blobs/:id — download bytes as an ArrayBuffer. */
-    async downloadBlob(blobId) {
-        const url = this.base + "/v1/blobs/" + encodeURIComponent(blobId);
+    /** 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: {
@@ -538,43 +551,43 @@ export class PaneClient {
         return res.arrayBuffer();
     }
     /**
-     * GET a blob's metadata only — useful before downloading large blobs, or
-     * for `pane blob show <id>` which doesn't want the bytes. Returns the full
-     * BlobRef (the same shape POST /v1/blobs returns): id, scope, mime, size,
+     * 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/blobs/:id/metadata which serves the JSON BlobRef
+     * 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(blobId) {
-        const r = await this.call("GET", "/v1/blobs/" + encodeURIComponent(blobId) + "/metadata");
+    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/blobs/:id — soft-delete (idempotent). */
-    async deleteBlob(blobId) {
-        const r = await this.call("DELETE", "/v1/blobs/" + encodeURIComponent(blobId));
+    /** 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 `blobId`. Default TTL is set by
-     * the relay (24h agent, session-TTL session, 30d artifact). `once: 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(blobId, opts = {}) {
-        const r = await this.call("POST", "/v1/blobs/" + encodeURIComponent(blobId) + "/tokens", { ttl_seconds: opts.ttlSeconds, once: opts.once });
+    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(blobId, tokenId) {
-        const r = await this.call("DELETE", "/v1/blobs/" +
-            encodeURIComponent(blobId) +
+    async revokeBlobToken(attachmentId, tokenId) {
+        const r = await this.call("DELETE", "/v1/attachments/" +
+            encodeURIComponent(attachmentId) +
             "/tokens/" +
             encodeURIComponent(tokenId));
         if (!r.ok)
@@ -582,7 +595,7 @@ export class PaneClient {
         return r.data;
     }
     /**
-     * GET /v1/blobs — list YOUR agent's non-deleted blobs (newest first).
+     * 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.
      */
@@ -593,39 +606,39 @@ export class PaneClient {
         if (opts.limit !== undefined)
             params.set("limit", String(opts.limit));
         const qs = params.toString();
-        const r = await this.call("GET", "/v1/blobs" + (qs ? "?" + qs : ""));
+        const r = await this.call("GET", "/v1/attachments" + (qs ? "?" + qs : ""));
         if (!r.ok)
             this.fail(r);
         return r.data;
     }
     /**
-     * GET /v1/blobs/:id/tokens — enumerate the capability tokens minted
-     * against one blob, including revoked rows (for audit). The plaintext
+     * 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(blobId) {
-        const r = await this.call("GET", "/v1/blobs/" + encodeURIComponent(blobId) + "/tokens");
+    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 blob_id (already reserved in the relay's DB with
+     * 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(blob_id)` to finalise.
+     * `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/blobs/presign", {
+        const r = await this.call("POST", "/v1/attachments/presign", {
             mime: opts.mime,
             size: opts.size,
             sha256: opts.sha256,
             scope: opts.scope,
-            session_id: opts.sessionId,
-            artifact_id: opts.artifactId,
+            surface_id: opts.surfaceId,
+            template_id: opts.templateId,
             filename: opts.filename,
         });
         if (!r.ok)
@@ -633,8 +646,8 @@ export class PaneClient {
         return r.data;
     }
     /** Finalise a presigned upload — relay HEADs the bytes, verifies, flips ready. */
-    async confirmBlob(blobId) {
-        const r = await this.call("POST", "/v1/blobs/" + encodeURIComponent(blobId) + "/confirm");
+    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,5 +1,5 @@
 export { PaneClient, PaneApiError } from "./client.js";
-export type { ClientOptions, RelayResponse, CreateArtifactRequest, CreateArtifactVersionRequest, PatchArtifactMetadataRequest, BlobRef, UploadBlobOptions, PresignBlobOptions, BlobTokenMintResponse, ListBlobsOptions, BlobTokenAuditEntry, BlobTokenListResponse, } 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";
@@ -7,4 +7,4 @@ export type { RegisterAgentOptions, RegisterAgentResult } from "./register.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, ParticipantSummary, ParticipantsList, SessionSummary, SessionsPage, MintParticipantResponse, 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/schemas.d.ts

@@ -16,7 +16,7 @@ export declare const callbackSchema: z.ZodObject<{
     secret: z.ZodString;
 }, z.core.$strip>;
 export declare const createSessionSchema: z.ZodObject<{
-    artifact: z.ZodUnion<readonly [z.ZodObject<{
+    template: z.ZodUnion<readonly [z.ZodObject<{
         id: z.ZodString;
         version: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
@@ -40,6 +40,7 @@ export declare const createSessionSchema: z.ZodObject<{
         secret: z.ZodString;
     }, z.core.$strip>>;
     title: z.ZodOptional<z.ZodString>;
+    context_key: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const createArtifactSchema: z.ZodObject<{
     name: z.ZodString;
@@ -81,7 +82,7 @@ export declare const submitFeedbackSchema: z.ZodObject<{
         note: "note";
     }>;
     message: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
-    session_id: z.ZodOptional<z.ZodString>;
+    surface_id: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /** @deprecated use `CreateSessionRequest` from ./types.js (same type). */
 export type CreateSessionInput = z.infer<typeof createSessionSchema>;
@@ -99,7 +100,7 @@ export declare const listSessionsQuerySchema: z.ZodObject<{
     }>>;
     limit: z.ZodOptional<z.ZodNumber>;
     cursor: z.ZodOptional<z.ZodString>;
-    artifact_id: z.ZodOptional<z.ZodString>;
+    template_id: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ListSessionsQuery = z.infer<typeof listSessionsQuerySchema>;
 export declare const mintParticipantSchema: z.ZodObject<{