langsmith 0.5.22 → 0.5.24

package/dist/utils/fast-safe-stringify/index.cjs

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateSerializedSize = estimateSerializedSize;
 exports.serialize = serialize;
 /* eslint-disable */
 // @ts-nocheck
@@ -60,6 +61,208 @@ function createDefaultReplacer(userReplacer) {
         return serializeWellKnownTypes(val);
     };
 }
+function estimateSerializedSize(value) {
+    try {
+        // Ancestor set for cycle detection. An object is only treated as
+        // circular if it appears on the current recursion path, not merely
+        // if it has been seen before elsewhere in the graph.
+        const ancestors = new Set();
+        let maxStringLen = 0;
+        // In Node / Bun, Buffer.byteLength is a fast native way to get UTF-8
+        // byte length without allocating an encoded copy. In other runtimes
+        // we fall back to code-unit length (a small under-estimate for
+        // non-ASCII text, which is acceptable for soft limits).
+        const byteLen = typeof Buffer !== "undefined" && typeof Buffer.byteLength === "function"
+            ? (s) => Buffer.byteLength(s, "utf8")
+            : (s) => s.length;
+        function estimateString(s) {
+            // +2 for the surrounding quotes. Escape expansion is not counted.
+            const n = byteLen(s);
+            if (n > maxStringLen)
+                maxStringLen = n;
+            return n + 2;
+        }
+        // Size of a byte sequence when rendered as a JSON array of decimal
+        // numbers: "[b0,b1,b2,...]". Each byte averages ~3.5 chars (value 0-9
+        // => 1 char, 10-99 => 2 chars, 100-255 => 3 chars; weighted mean over
+        // a uniform distribution is ~2.81, plus one comma per element except
+        // the last). Round up to 4 bytes/element for a small safety margin.
+        function estimateByteArrayJson(byteLength) {
+            if (byteLength === 0)
+                return 2; // "[]"
+            return 2 + byteLength * 4;
+        }
+        // Returns true for values that JSON.stringify drops when they appear
+        // as an object property (as opposed to an array element, where they
+        // become "null").
+        function isDropped(v) {
+            return (v === undefined || typeof v === "function" || typeof v === "symbol");
+        }
+        // In arrays, undefined / function / symbol become "null" (4 bytes).
+        function estimateInArray(v) {
+            if (v === undefined || typeof v === "function" || typeof v === "symbol") {
+                return 4;
+            }
+            return estimate(v);
+        }
+        function estimate(val) {
+            if (val === null)
+                return 4; // "null"
+            if (val === undefined)
+                return 0; // top-level or property context; array handled separately
+            const t = typeof val;
+            if (t === "boolean")
+                return 5; // "true" / "false" upper bound
+            if (t === "number") {
+                if (!Number.isFinite(val))
+                    return 4; // "null"
+                // Convert to string to get exact length. This is cheap for numbers
+                // (V8 caches small-number strings) and makes the estimate far
+                // tighter for common cases like integer arrays.
+                return val.toString().length;
+            }
+            if (t === "bigint") {
+                // Our replacer renders BigInt via .toString(), then JSON.stringify
+                // quotes it.
+                return val.toString().length + 2;
+            }
+            if (t === "string")
+                return estimateString(val);
+            if (t === "function" || t === "symbol")
+                return 0;
+            // Objects from here on.
+            const obj = val;
+            // Well-known types handled by our replacer.
+            if (obj instanceof Date)
+                return 26; // "2024-01-01T00:00:00.000Z"
+            if (obj instanceof RegExp)
+                return byteLen(obj.toString()) + 2;
+            if (obj instanceof Error) {
+                const name = obj.name ?? "";
+                const message = obj.message ?? "";
+                // {"name":"...","message":"..."}
+                return 22 + byteLen(name) + byteLen(message);
+            }
+            // Binary data types. These commonly appear in LLM payloads (images,
+            // audio) and their JSON representations vary widely.
+            if (typeof Buffer !== "undefined" && obj instanceof Buffer) {
+                // { "type": "Buffer", "data": [0, 1, 2, ...] }
+                return 28 + estimateByteArrayJson(obj.byteLength);
+            }
+            if (ArrayBuffer.isView(obj)) {
+                if (obj instanceof DataView) {
+                    // DataView has no enumerable own properties; serializes as "{}".
+                    return 2;
+                }
+                // Typed arrays serialize as {"0":v0,"1":v1,...} (keyed objects),
+                // which is much larger than a plain array would be. Per element
+                // cost: digits for index + digits for value + ":" + "," + quotes.
+                const len = obj.length ?? 0;
+                const isFloat = obj instanceof Float32Array || obj instanceof Float64Array;
+                // Index digits grow with len; worst-case per element:
+                //   "NNN":V,   where NNN = log10(len) digits and V depends on type.
+                // Loose but safe bounds: integer views ~12 chars/element, float
+                // views ~30 chars/element (Float32 ToString can be up to ~17 chars).
+                const perElement = isFloat ? 30 : 12;
+                return 2 + len * perElement;
+            }
+            if (obj instanceof ArrayBuffer) {
+                // Plain ArrayBuffer has no enumerable properties; serializes as "{}".
+                return 2;
+            }
+            if (ancestors.has(obj)) {
+                // Cycle: our decirc fallback replaces with { result: "[Circular]" }.
+                return 24;
+            }
+            // Custom toJSON (Decimal.js, Moment, Luxon, Mongoose docs, etc.).
+            // This runs after explicit built-in / binary cases above so known
+            // types (for example Buffer) use their dedicated fast-path sizing
+            // logic instead of duck-typing through toJSON().
+            if (typeof obj.toJSON === "function") {
+                let projected;
+                try {
+                    projected = obj.toJSON("");
+                }
+                catch {
+                    // If toJSON throws, JSON.stringify would also throw and our
+                    // serializer would emit "[Unserializable]" (~16 bytes).
+                    return 16;
+                }
+                ancestors.add(obj);
+                const size = estimate(projected);
+                ancestors.delete(obj);
+                return size;
+            }
+            ancestors.add(obj);
+            let size;
+            if (Array.isArray(obj)) {
+                size = 2; // []
+                const len = obj.length;
+                for (let i = 0; i < len; i++) {
+                    size += estimateInArray(obj[i]);
+                    if (i < len - 1)
+                        size += 1; // comma
+                }
+            }
+            else if (obj instanceof Map) {
+                // Rendered as { k: v, ... } via Object.fromEntries.
+                size = 2;
+                let emitted = 0;
+                for (const [k, v] of obj) {
+                    if (isDropped(v))
+                        continue;
+                    if (emitted > 0)
+                        size += 1; // comma
+                    const keyStr = typeof k === "string" ? k : String(k);
+                    size += byteLen(keyStr) + 3; // "key":
+                    size += estimate(v);
+                    emitted++;
+                }
+            }
+            else if (obj instanceof Set) {
+                // Rendered as [v, ...] via Array.from.
+                size = 2;
+                let emitted = 0;
+                for (const v of obj) {
+                    if (emitted > 0)
+                        size += 1; // comma
+                    size += estimateInArray(v);
+                    emitted++;
+                }
+            }
+            else {
+                size = 2; // {}
+                let emitted = 0;
+                // Object.keys only returns own enumerable string keys, matching
+                // JSON.stringify.
+                const keys = Object.keys(obj);
+                for (let i = 0; i < keys.length; i++) {
+                    const key = keys[i];
+                    const v = obj[key];
+                    if (isDropped(v))
+                        continue;
+                    if (emitted > 0)
+                        size += 1; // comma
+                    size += byteLen(key) + 3; // "key":
+                    size += estimate(v);
+                    emitted++;
+                }
+            }
+            ancestors.delete(obj);
+            return size;
+        }
+        const size = estimate(value);
+        return { size, maxStringLen };
+    }
+    catch {
+        // If the estimator itself hits an unexpected edge case, fall back to the
+        // exact serialized size. This preserves correctness of queue-size
+        // accounting at the cost of a slower hot path for that one payload.
+        // We cannot cheaply recover maxStringLen here, so report 0: the worker
+        // gate will then fall back to sync serialization, which is safe.
+        return { size: serialize(value).length, maxStringLen: 0 };
+    }
+}
 // Regular stringify
 function serialize(obj, errorContext, replacer, spacer, options) {
     try {

package/dist/utils/fast-safe-stringify/index.d.ts

@@ -1 +1,47 @@
+/**
+ * Estimate the serialized JSON byte size of a value without actually
+ * serializing it. Used on hot paths (enqueuing runs for batched tracing)
+ * where the exact serialized size is not required -- only a reasonable
+ * approximation for soft memory accounting.
+ *
+ * Walks the object graph in O(n) without allocating a JSON string,
+ * avoiding the event-loop blocking that JSON.stringify causes on large
+ * payloads.
+ *
+ * Accuracy notes (all estimates are approximate, never exact):
+ * - Strings: UTF-8 byte length via Buffer.byteLength when available,
+ *   falling back to code-unit length for non-Node environments. Does
+ *   not account for escape expansion (\", \\, control chars, surrogate
+ *   escapes) which is usually a small fraction of total size.
+ * - Binary data (Buffer / typed arrays / ArrayBuffer / DataView): sized
+ *   from their JSON.stringify representations where practical
+ *   ({ type: "Buffer", data: [...] } for Buffer, keyed objects for typed
+ *   arrays). DataView and ArrayBuffer themselves have no enumerable own
+ *   properties and serialize as "{}". Each byte contributes ~3.5
+ *   characters on average in Buffer's decimal-array representation
+ *   (digit(s) + comma).
+ * - Other objects with toJSON(): we invoke toJSON() once and estimate
+ *   the result. This matches JSON.stringify semantics for libraries
+ *   like Decimal.js, Moment, Luxon, Mongoose documents, etc.
+ * - Cycles: detected via an ancestor-path set that is pushed/popped
+ *   during recursion. This matches JSON.stringify semantics --
+ *   repeated references that are *not* on the current ancestor chain
+ *   (shared subobjects) are counted every time they appear, because
+ *   JSON.stringify will serialize them every time.
+ * - No depth limit (JSON.stringify has none either).
+ */
+export interface EstimatedSize {
+    /** Approximate serialized JSON byte size. */
+    size: number;
+    /**
+     * Length (in UTF-8 bytes) of the longest single string value encountered
+     * anywhere in the payload graph. Callers can use this as a shape-aware
+     * dispatch signal -- for example, to decide whether to offload serialize
+     * to a worker thread (which only pays off when a payload contains one
+     * or more large strings, since V8 shares string storage across isolates
+     * via refcount).
+     */
+    maxStringLen: number;
+}
+export declare function estimateSerializedSize(value: unknown): EstimatedSize;
 export declare function serialize(obj: any, errorContext?: any, replacer?: any, spacer?: any, options?: any): Uint8Array<ArrayBuffer>;

package/dist/utils/fast-safe-stringify/index.js

@@ -57,6 +57,208 @@ function createDefaultReplacer(userReplacer) {
         return serializeWellKnownTypes(val);
     };
 }
+export function estimateSerializedSize(value) {
+    try {
+        // Ancestor set for cycle detection. An object is only treated as
+        // circular if it appears on the current recursion path, not merely
+        // if it has been seen before elsewhere in the graph.
+        const ancestors = new Set();
+        let maxStringLen = 0;
+        // In Node / Bun, Buffer.byteLength is a fast native way to get UTF-8
+        // byte length without allocating an encoded copy. In other runtimes
+        // we fall back to code-unit length (a small under-estimate for
+        // non-ASCII text, which is acceptable for soft limits).
+        const byteLen = typeof Buffer !== "undefined" && typeof Buffer.byteLength === "function"
+            ? (s) => Buffer.byteLength(s, "utf8")
+            : (s) => s.length;
+        function estimateString(s) {
+            // +2 for the surrounding quotes. Escape expansion is not counted.
+            const n = byteLen(s);
+            if (n > maxStringLen)
+                maxStringLen = n;
+            return n + 2;
+        }
+        // Size of a byte sequence when rendered as a JSON array of decimal
+        // numbers: "[b0,b1,b2,...]". Each byte averages ~3.5 chars (value 0-9
+        // => 1 char, 10-99 => 2 chars, 100-255 => 3 chars; weighted mean over
+        // a uniform distribution is ~2.81, plus one comma per element except
+        // the last). Round up to 4 bytes/element for a small safety margin.
+        function estimateByteArrayJson(byteLength) {
+            if (byteLength === 0)
+                return 2; // "[]"
+            return 2 + byteLength * 4;
+        }
+        // Returns true for values that JSON.stringify drops when they appear
+        // as an object property (as opposed to an array element, where they
+        // become "null").
+        function isDropped(v) {
+            return (v === undefined || typeof v === "function" || typeof v === "symbol");
+        }
+        // In arrays, undefined / function / symbol become "null" (4 bytes).
+        function estimateInArray(v) {
+            if (v === undefined || typeof v === "function" || typeof v === "symbol") {
+                return 4;
+            }
+            return estimate(v);
+        }
+        function estimate(val) {
+            if (val === null)
+                return 4; // "null"
+            if (val === undefined)
+                return 0; // top-level or property context; array handled separately
+            const t = typeof val;
+            if (t === "boolean")
+                return 5; // "true" / "false" upper bound
+            if (t === "number") {
+                if (!Number.isFinite(val))
+                    return 4; // "null"
+                // Convert to string to get exact length. This is cheap for numbers
+                // (V8 caches small-number strings) and makes the estimate far
+                // tighter for common cases like integer arrays.
+                return val.toString().length;
+            }
+            if (t === "bigint") {
+                // Our replacer renders BigInt via .toString(), then JSON.stringify
+                // quotes it.
+                return val.toString().length + 2;
+            }
+            if (t === "string")
+                return estimateString(val);
+            if (t === "function" || t === "symbol")
+                return 0;
+            // Objects from here on.
+            const obj = val;
+            // Well-known types handled by our replacer.
+            if (obj instanceof Date)
+                return 26; // "2024-01-01T00:00:00.000Z"
+            if (obj instanceof RegExp)
+                return byteLen(obj.toString()) + 2;
+            if (obj instanceof Error) {
+                const name = obj.name ?? "";
+                const message = obj.message ?? "";
+                // {"name":"...","message":"..."}
+                return 22 + byteLen(name) + byteLen(message);
+            }
+            // Binary data types. These commonly appear in LLM payloads (images,
+            // audio) and their JSON representations vary widely.
+            if (typeof Buffer !== "undefined" && obj instanceof Buffer) {
+                // { "type": "Buffer", "data": [0, 1, 2, ...] }
+                return 28 + estimateByteArrayJson(obj.byteLength);
+            }
+            if (ArrayBuffer.isView(obj)) {
+                if (obj instanceof DataView) {
+                    // DataView has no enumerable own properties; serializes as "{}".
+                    return 2;
+                }
+                // Typed arrays serialize as {"0":v0,"1":v1,...} (keyed objects),
+                // which is much larger than a plain array would be. Per element
+                // cost: digits for index + digits for value + ":" + "," + quotes.
+                const len = obj.length ?? 0;
+                const isFloat = obj instanceof Float32Array || obj instanceof Float64Array;
+                // Index digits grow with len; worst-case per element:
+                //   "NNN":V,   where NNN = log10(len) digits and V depends on type.
+                // Loose but safe bounds: integer views ~12 chars/element, float
+                // views ~30 chars/element (Float32 ToString can be up to ~17 chars).
+                const perElement = isFloat ? 30 : 12;
+                return 2 + len * perElement;
+            }
+            if (obj instanceof ArrayBuffer) {
+                // Plain ArrayBuffer has no enumerable properties; serializes as "{}".
+                return 2;
+            }
+            if (ancestors.has(obj)) {
+                // Cycle: our decirc fallback replaces with { result: "[Circular]" }.
+                return 24;
+            }
+            // Custom toJSON (Decimal.js, Moment, Luxon, Mongoose docs, etc.).
+            // This runs after explicit built-in / binary cases above so known
+            // types (for example Buffer) use their dedicated fast-path sizing
+            // logic instead of duck-typing through toJSON().
+            if (typeof obj.toJSON === "function") {
+                let projected;
+                try {
+                    projected = obj.toJSON("");
+                }
+                catch {
+                    // If toJSON throws, JSON.stringify would also throw and our
+                    // serializer would emit "[Unserializable]" (~16 bytes).
+                    return 16;
+                }
+                ancestors.add(obj);
+                const size = estimate(projected);
+                ancestors.delete(obj);
+                return size;
+            }
+            ancestors.add(obj);
+            let size;
+            if (Array.isArray(obj)) {
+                size = 2; // []
+                const len = obj.length;
+                for (let i = 0; i < len; i++) {
+                    size += estimateInArray(obj[i]);
+                    if (i < len - 1)
+                        size += 1; // comma
+                }
+            }
+            else if (obj instanceof Map) {
+                // Rendered as { k: v, ... } via Object.fromEntries.
+                size = 2;
+                let emitted = 0;
+                for (const [k, v] of obj) {
+                    if (isDropped(v))
+                        continue;
+                    if (emitted > 0)
+                        size += 1; // comma
+                    const keyStr = typeof k === "string" ? k : String(k);
+                    size += byteLen(keyStr) + 3; // "key":
+                    size += estimate(v);
+                    emitted++;
+                }
+            }
+            else if (obj instanceof Set) {
+                // Rendered as [v, ...] via Array.from.
+                size = 2;
+                let emitted = 0;
+                for (const v of obj) {
+                    if (emitted > 0)
+                        size += 1; // comma
+                    size += estimateInArray(v);
+                    emitted++;
+                }
+            }
+            else {
+                size = 2; // {}
+                let emitted = 0;
+                // Object.keys only returns own enumerable string keys, matching
+                // JSON.stringify.
+                const keys = Object.keys(obj);
+                for (let i = 0; i < keys.length; i++) {
+                    const key = keys[i];
+                    const v = obj[key];
+                    if (isDropped(v))
+                        continue;
+                    if (emitted > 0)
+                        size += 1; // comma
+                    size += byteLen(key) + 3; // "key":
+                    size += estimate(v);
+                    emitted++;
+                }
+            }
+            ancestors.delete(obj);
+            return size;
+        }
+        const size = estimate(value);
+        return { size, maxStringLen };
+    }
+    catch {
+        // If the estimator itself hits an unexpected edge case, fall back to the
+        // exact serialized size. This preserves correctness of queue-size
+        // accounting at the cost of a slower hot path for that one payload.
+        // We cannot cheaply recover maxStringLen here, so report 0: the worker
+        // gate will then fall back to sync serialization, which is safe.
+        return { size: serialize(value).length, maxStringLen: 0 };
+    }
+}
 // Regular stringify
 export function serialize(obj, errorContext, replacer, spacer, options) {
     try {

package/dist/utils/jestlike/index.cjs

@@ -48,7 +48,7 @@ exports._objectHash = _objectHash;
 exports.generateWrapperFromJestlikeMethods = generateWrapperFromJestlikeMethods;
 exports.isInTestContext = isInTestContext;
 const crypto_1 = __importDefault(require("crypto"));
-const uuid_1 = require("uuid");
+const index_js_1 = require("../uuid/src/index.cjs");
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const fs = __importStar(require("node:fs/promises"));
@@ -137,7 +137,7 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
             catch (e) {
                 // Naming collision
                 if (e?.name === "LangSmithConflictError") {
-                    const ent = (0, uuid_1.v4)().slice(0, 6);
+                    const ent = (0, index_js_1.v4)().slice(0, 6);
                     experimentName = `${experimentName}-${ent}`;
                 }
                 else {
@@ -158,7 +158,7 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
             inputsHash: _objectHash(inputs),
             outputsHash: _objectHash(outputs ?? {}),
         });
-        return (0, uuid_1.v5)(identifier, constants_js_1.UUID5_NAMESPACE);
+        return (0, index_js_1.v5)(identifier, constants_js_1.UUID5_NAMESPACE);
     }
     async function syncExample(params) {
         const { client, exampleId, inputs, outputs, metadata, split, createdAt, datasetId, } = params;
@@ -268,7 +268,7 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
             });
             return method(suiteName, () => {
                 const startTime = new Date();
-                const suiteUuid = (0, uuid_1.v4)();
+                const suiteUuid = (0, index_js_1.v4)();
                 const environment = experimentConfig?.metadata?.ENVIRONMENT ??
                     (0, env_js_1.getEnvironmentVariable)("ENVIRONMENT");
                 const nodeEnv = experimentConfig?.metadata?.NODE_ENV ??
@@ -418,7 +418,7 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
             }
             const totalRuns = config?.repetitions ?? 1;
             for (let i = 0; i < totalRuns; i += 1) {
-                const testUuid = (0, uuid_1.v4)().replace(/-/g, "").slice(0, 13);
+                const testUuid = (0, index_js_1.v4)().replace(/-/g, "").slice(0, 13);
                 // Jest will not group tests under the same "describe" group if you await the test and
                 // total runs is greater than 1.
                 const resultsPath = path.join(os.tmpdir(), "langsmith_test_results", `${testUuid}.json`);

package/dist/utils/jestlike/index.js

@@ -1,7 +1,7 @@
 /* eslint-disable import/no-extraneous-dependencies */
 /* eslint-disable @typescript-eslint/no-namespace */
 import crypto from "crypto";
-import { v4, v5 } from "uuid";
+import { v4, v5 } from "../uuid/src/index.js";
 import * as os from "node:os";
 import * as path from "node:path";
 import * as fs from "node:fs/promises";

package/dist/utils/jestlike/vendor/evaluatedBy.cjs

@@ -4,7 +4,7 @@ exports.wrapEvaluator = wrapEvaluator;
 exports.evaluatedBy = evaluatedBy;
 const traceable_js_1 = require("../../../traceable.cjs");
 const globals_js_1 = require("../globals.cjs");
-const uuid_1 = require("uuid");
+const index_js_1 = require("../../uuid/src/index.cjs");
 function isEvaluationResult(x) {
     return (x != null &&
         typeof x === "object" &&
@@ -22,7 +22,7 @@ function wrapEvaluator(evaluator) {
                 `See this page for more information: https://docs.smith.langchain.com/evaluation/how_to_guides/vitest_jest`,
             ].join("\n"));
         }
-        let evalRunId = config?.runId ?? config?.id ?? (0, uuid_1.v7)();
+        let evalRunId = config?.runId ?? config?.id ?? (0, index_js_1.v7)();
         let evalResult;
         if ((0, globals_js_1.trackingEnabled)(context)) {
             const wrappedEvaluator = (0, traceable_js_1.traceable)(async (_runTree, params) => {
@@ -83,7 +83,7 @@ async function evaluatedBy(outputs, evaluator) {
         ].join("\n"));
     }
     const wrappedEvaluator = wrapEvaluator(evaluator);
-    const evalRunId = (0, uuid_1.v7)();
+    const evalRunId = (0, index_js_1.v7)();
     const evalResult = await wrappedEvaluator({
         inputs: context.currentExample?.inputs ?? {},
         referenceOutputs: context?.currentExample?.outputs ?? {},

package/dist/utils/jestlike/vendor/evaluatedBy.js

@@ -1,6 +1,6 @@
 import { ROOT, traceable } from "../../../traceable.js";
 import { testWrapperAsyncLocalStorageInstance, _logTestFeedback, trackingEnabled, } from "../globals.js";
-import { v7 } from "uuid";
+import { v7 } from "../../uuid/src/index.js";
 function isEvaluationResult(x) {
     return (x != null &&
         typeof x === "object" &&

package/dist/utils/prompts.cjs

@@ -1,8 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePromptIdentifier = parsePromptIdentifier;
+exports.parseHubIdentifier = parseHubIdentifier;
 const error_js_1 = require("./error.cjs");
-function parsePromptIdentifier(identifier) {
+/**
+ * Parse a hub repo identifier (owner/name:hash, name, etc.).
+ *
+ * Prompts, agents, and skills share the same identifier grammar on Hub.
+ */
+function parseHubIdentifier(identifier) {
     if (!identifier ||
         identifier.split("/").length > 2 ||
         identifier.startsWith("/") ||

package/dist/utils/prompts.d.ts

@@ -1 +1,6 @@
-export declare function parsePromptIdentifier(identifier: string): [string, string, string];
+/**
+ * Parse a hub repo identifier (owner/name:hash, name, etc.).
+ *
+ * Prompts, agents, and skills share the same identifier grammar on Hub.
+ */
+export declare function parseHubIdentifier(identifier: string): [string, string, string];

package/dist/utils/prompts.js

@@ -1,5 +1,10 @@
 import { getInvalidPromptIdentifierMsg } from "./error.js";
-export function parsePromptIdentifier(identifier) {
+/**
+ * Parse a hub repo identifier (owner/name:hash, name, etc.).
+ *
+ * Prompts, agents, and skills share the same identifier grammar on Hub.
+ */
+export function parseHubIdentifier(identifier) {
     if (!identifier ||
         identifier.split("/").length > 2 ||
         identifier.startsWith("/") ||