@kweaver-ai/kweaver-sdk 0.8.1 → 0.8.3

package/dist/api/resources.d.ts

@@ -0,0 +1,94 @@
+export declare const RESOURCE_LIST_DEFAULT_LIMIT = 30;
+/** Field metadata for a resource schema. */
+export interface ViewField {
+    name: string;
+    type: string;
+    display_name?: string;
+    comment?: string;
+}
+/** Normalized vega-backend Resource model. */
+export interface Resource {
+    id: string;
+    name: string;
+    catalog_id: string;
+    category: string;
+    source_identifier?: string;
+    status?: string;
+    schema_definition?: ViewField[];
+    logic_definition?: unknown;
+}
+export declare function parseResource(raw: Record<string, unknown>): Resource;
+export interface CreateResourceOptions {
+    baseUrl: string;
+    accessToken: string;
+    name: string;
+    datasourceId: string;
+    table: string;
+    fields?: Array<{
+        name: string;
+        type: string;
+    }>;
+    businessDomain?: string;
+}
+export declare function createResource(options: CreateResourceOptions): Promise<string>;
+export interface ListResourcesOptions {
+    baseUrl: string;
+    accessToken: string;
+    businessDomain?: string;
+    /** Filter by catalog (data source) id. */
+    datasourceId?: string;
+    /** Server-side name filter. */
+    name?: string;
+    /** Category filter (e.g. "table", "logicview"). */
+    category?: string;
+    /** Max items; ignored when <= 0. */
+    limit?: number;
+}
+export declare function listResources(options: ListResourcesOptions): Promise<Resource[]>;
+export interface DeleteResourceOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    businessDomain?: string;
+}
+export declare function deleteResource(options: DeleteResourceOptions): Promise<void>;
+export interface GetResourceOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    businessDomain?: string;
+}
+export declare function getResource(options: GetResourceOptions): Promise<Resource>;
+export interface FindResourceOptions {
+    baseUrl: string;
+    accessToken: string;
+    businessDomain?: string;
+    /** Resource name to search for. */
+    name: string;
+    /** Filter by catalog (data source) id. */
+    datasourceId?: string;
+    /** When true, apply client-side exact name match after server filter (default false). */
+    exact?: boolean;
+    /** When true, poll until a result appears or timeout (default false). */
+    wait?: boolean;
+    /** Total wait budget in ms (default 30000). Only used when wait is true. */
+    timeoutMs?: number;
+}
+export declare function findResource(options: FindResourceOptions): Promise<Resource[]>;
+export interface QueryResourceOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    offset?: number;
+    limit?: number;
+    needTotal?: boolean;
+    filterCondition?: unknown;
+    sort?: string;
+    direction?: "asc" | "desc";
+    businessDomain?: string;
+}
+export interface ResourceQueryResult {
+    entries?: unknown;
+    total_count?: number;
+}
+export declare function queryResource(options: QueryResourceOptions): Promise<ResourceQueryResult>;

package/dist/api/resources.js

@@ -0,0 +1,166 @@
+import { HttpError } from "../utils/http.js";
+import { buildHeaders } from "./headers.js";
+export const RESOURCE_LIST_DEFAULT_LIMIT = 30;
+export function parseResource(raw) {
+    const res = {
+        id: String(raw.id ?? ""),
+        name: String(raw.name ?? ""),
+        catalog_id: String(raw.catalog_id ?? ""),
+        category: String(raw.category ?? ""),
+    };
+    if (raw.source_identifier != null)
+        res.source_identifier = String(raw.source_identifier);
+    if (raw.status != null)
+        res.status = String(raw.status);
+    if (Array.isArray(raw.schema_definition) && raw.schema_definition.length > 0) {
+        res.schema_definition = raw.schema_definition.map((f) => ({
+            name: String(f.name ?? ""),
+            type: String(f.type ?? "varchar"),
+            display_name: f.display_name != null ? String(f.display_name) : undefined,
+            comment: f.comment != null ? String(f.comment) : undefined,
+        }));
+    }
+    if (raw.logic_definition !== undefined)
+        res.logic_definition = raw.logic_definition;
+    return res;
+}
+function extractListPayload(data) {
+    if (Array.isArray(data))
+        return data;
+    if (data && typeof data === "object") {
+        const obj = data;
+        const items = obj.entries ?? obj.data;
+        if (Array.isArray(items))
+            return items;
+    }
+    return [];
+}
+export async function createResource(options) {
+    const { baseUrl, accessToken, name, datasourceId, table, fields = [], businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/vega-backend/v1/resources`;
+    const body = {
+        name,
+        catalog_id: datasourceId,
+        category: "table",
+        source_identifier: table,
+    };
+    if (fields.length > 0)
+        body.schema_definition = fields;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    const data = JSON.parse(responseBody);
+    return String(data.id ?? "");
+}
+export async function listResources(options) {
+    const { baseUrl, accessToken, businessDomain = "bd_public", datasourceId, name, category, limit = RESOURCE_LIST_DEFAULT_LIMIT, } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/vega-backend/v1/resources`);
+    if (datasourceId)
+        url.searchParams.set("catalog_id", datasourceId);
+    if (name)
+        url.searchParams.set("name", name);
+    if (category)
+        url.searchParams.set("category", category);
+    if (limit && limit > 0)
+        url.searchParams.set("limit", String(limit));
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const bodyText = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, bodyText);
+    const parsed = JSON.parse(bodyText);
+    const items = extractListPayload(parsed);
+    return items
+        .filter((item) => item != null && typeof item === "object")
+        .map(parseResource);
+}
+export async function deleteResource(options) {
+    const { baseUrl, accessToken, id, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/vega-backend/v1/resources/${encodeURIComponent(id)}`;
+    const response = await fetch(url, {
+        method: "DELETE",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const bodyText = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, bodyText);
+}
+export async function getResource(options) {
+    const { baseUrl, accessToken, id, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/vega-backend/v1/resources/${encodeURIComponent(id)}`;
+    const response = await fetch(url, {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    const parsed = JSON.parse(body);
+    // vega-backend GET /:id returns { entries: [...] } (supports comma-separated ids)
+    const items = extractListPayload(parsed);
+    const raw = items.length > 0 ? items[0] : (parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null);
+    if (!raw || typeof raw !== "object")
+        throw new HttpError(500, "Invalid response", body);
+    return parseResource(raw);
+}
+function sleepMs(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function findResource(options) {
+    const { baseUrl, accessToken, businessDomain = "bd_public", name, datasourceId, exact = false, wait = false, timeoutMs = 30_000, } = options;
+    const deadline = Date.now() + timeoutMs;
+    let attempt = 0;
+    while (true) {
+        const list = await listResources({ baseUrl, accessToken, businessDomain, datasourceId, name });
+        const results = exact ? list.filter((v) => v.name === name) : list;
+        if (results.length > 0 || !wait || Date.now() >= deadline)
+            return results;
+        const delayMs = Math.min(5000, 1000 * 2 ** attempt);
+        attempt += 1;
+        await sleepMs(delayMs);
+    }
+}
+export async function queryResource(options) {
+    const { baseUrl, accessToken, id, offset = 0, limit = 50, needTotal = false, filterCondition, sort, direction, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/vega-backend/v1/resources/${encodeURIComponent(id)}/data`;
+    const body = { offset, limit, need_total: needTotal };
+    if (filterCondition !== undefined)
+        body.filter_condition = filterCondition;
+    if (sort !== undefined)
+        body.sort = sort;
+    if (direction !== undefined)
+        body.direction = direction;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+            "x-http-method-override": "GET",
+        },
+        body: JSON.stringify(body),
+    });
+    const bodyText = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, bodyText);
+    const parsed = JSON.parse(bodyText);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+    }
+    return {};
+}

package/dist/api/semantic-search.d.ts

@@ -18,4 +18,9 @@ export interface KnSearchHttpOptions {
     businessDomain?: string;
     onlySchema?: boolean;
 }
+/**
+ * @deprecated Use Context Loader `search_schema` for new schema discovery integrations.
+ * The HTTP `kn_search` endpoint is kept only as a compatibility entry point
+ * and may not receive new `search_schema` capabilities.
+ */
 export declare function knSearchHttp(options: KnSearchHttpOptions): Promise<string>;

package/dist/api/semantic-search.js

@@ -22,6 +22,11 @@ export async function semanticSearch(options) {
     }
     return body;
 }
+/**
+ * @deprecated Use Context Loader `search_schema` for new schema discovery integrations.
+ * The HTTP `kn_search` endpoint is kept only as a compatibility entry point
+ * and may not receive new `search_schema` capabilities.
+ */
 export async function knSearchHttp(options) {
     const { baseUrl, accessToken, knId, query, businessDomain = "bd_public", onlySchema = false, } = options;
     const base = baseUrl.replace(/\/+$/, "");

package/dist/api/skills.d.ts

@@ -1,11 +1,13 @@
 export type SkillStatus = "unpublish" | "published" | "offline";
 export type SkillFileType = "zip" | "content";
+export type SkillEditableStatus = SkillStatus | "editing";
+export type SkillCategory = "other_category" | "system";
 export interface SkillSummary {
     id: string;
     name: string;
     description?: string;
     version?: string;
-    status?: SkillStatus;
+    status?: SkillEditableStatus;
     source?: string;
     create_user?: string;
     create_time?: number;
@@ -29,7 +31,7 @@ export interface SkillContentIndex {
     id: string;
     url: string;
     files: SkillFileSummary[];
-    status?: SkillStatus;
+    status?: SkillEditableStatus;
 }
 export interface SkillFileReadResult {
     id: string;
@@ -54,6 +56,22 @@ export interface UpdateSkillStatusResult {
     id: string;
     status: SkillStatus;
 }
+export interface UpdateSkillMetadataResult {
+    id: string;
+    version?: string;
+    status?: SkillEditableStatus;
+}
+export interface UpdateSkillPackageResult {
+    id: string;
+    version?: string;
+    status?: SkillEditableStatus;
+}
+export interface SkillReleaseHistoryInfo extends SkillSummary {
+    category?: SkillCategory;
+    release_desc?: string;
+    release_user?: string;
+    release_time?: number;
+}
 export interface SkillListResult {
     total_count?: number;
     total?: number;
@@ -104,6 +122,23 @@ export interface RegisterSkillZipOptions extends SkillApiBaseOptions {
     source?: string;
     extendInfo?: Record<string, unknown>;
 }
+export interface UpdateSkillMetadataOptions extends SkillApiBaseOptions {
+    skillId: string;
+    name: string;
+    description: string;
+    category: SkillCategory;
+    source?: string;
+    extendInfo?: Record<string, unknown>;
+}
+export interface UpdateSkillPackageContentOptions extends SkillApiBaseOptions {
+    skillId: string;
+    content: string;
+}
+export interface UpdateSkillPackageZipOptions extends SkillApiBaseOptions {
+    skillId: string;
+    filename: string;
+    bytes: Uint8Array;
+}
 export interface UpdateSkillStatusOptions extends SkillApiBaseOptions {
     skillId: string;
     status: SkillStatus;
@@ -119,23 +154,61 @@ export interface DownloadedSkillArchive {
     fileName: string;
     bytes: Uint8Array;
 }
+export interface SkillHistoryVersionOptions extends SkillApiBaseOptions {
+    skillId: string;
+    version: string;
+}
 export interface InstallSkillArchiveOptions {
     bytes: Uint8Array;
     directory: string;
     force?: boolean;
 }
+export interface SkillManagementContentData {
+    skill_id: string;
+    name: string;
+    description: string;
+    version: string;
+    status: SkillEditableStatus;
+    source: string;
+    file_type: "zip" | "content";
+    url?: string;
+    content?: string;
+    files: SkillFileSummary[];
+}
+export interface GetSkillManagementContentOptions extends SkillApiBaseOptions {
+    skillId: string;
+    responseMode?: "url" | "content";
+}
+export interface ReadSkillManagementFileOptions extends SkillApiBaseOptions {
+    skillId: string;
+    relPath: string;
+}
+export interface DownloadSkillManagementOptions extends SkillApiBaseOptions {
+    skillId: string;
+    responseMode?: "url" | "content";
+}
 export declare function listSkills(options: ListSkillsOptions): Promise<SkillListResult>;
 export declare function listSkillMarket(options: ListSkillMarketOptions): Promise<SkillListResult>;
 export declare function getSkill(options: GetSkillOptions): Promise<SkillInfo>;
+export declare function getSkillMarketDetail(options: GetSkillOptions): Promise<SkillInfo>;
 export declare function deleteSkill(options: GetSkillOptions): Promise<DeleteSkillResult>;
 export declare function updateSkillStatus(options: UpdateSkillStatusOptions): Promise<UpdateSkillStatusResult>;
+export declare function updateSkillMetadata(options: UpdateSkillMetadataOptions): Promise<UpdateSkillMetadataResult>;
 export declare function registerSkillContent(options: RegisterSkillContentOptions): Promise<RegisterSkillResult>;
 export declare function registerSkillZip(options: RegisterSkillZipOptions): Promise<RegisterSkillResult>;
+export declare function updateSkillPackageContent(options: UpdateSkillPackageContentOptions): Promise<UpdateSkillPackageResult>;
+export declare function updateSkillPackageZip(options: UpdateSkillPackageZipOptions): Promise<UpdateSkillPackageResult>;
 export declare function getSkillContentIndex(options: GetSkillOptions): Promise<SkillContentIndex>;
 export declare function fetchSkillContent(options: GetSkillOptions): Promise<string>;
 export declare function readSkillFile(options: ReadSkillFileOptions): Promise<SkillFileReadResult>;
 export declare function fetchSkillFile(options: ReadSkillFileOptions): Promise<Uint8Array>;
 export declare function downloadSkill(options: DownloadSkillOptions): Promise<DownloadedSkillArchive>;
+export declare function listSkillHistory(options: GetSkillOptions): Promise<SkillReleaseHistoryInfo[]>;
+export declare function republishSkillHistory(options: SkillHistoryVersionOptions): Promise<UpdateSkillPackageResult>;
+export declare function publishSkillHistory(options: SkillHistoryVersionOptions): Promise<UpdateSkillPackageResult>;
+export declare function getSkillManagementContent(options: GetSkillManagementContentOptions): Promise<SkillManagementContentData>;
+export declare function readSkillManagementFile(options: ReadSkillManagementFileOptions): Promise<SkillFileReadResult>;
+export declare function downloadSkillManagementArchive(options: DownloadSkillManagementOptions): Promise<DownloadedSkillArchive>;
 export declare function installSkillArchive(options: InstallSkillArchiveOptions): {
     directory: string;
 };

package/dist/api/skills.js

@@ -87,6 +87,11 @@ export async function getSkill(options) {
     const { body } = await fetchTextOrThrow(url, { headers: baseHeaders(options) });
     return normalizeSkillId(unwrapEnvelope(body));
 }
+export async function getSkillMarketDetail(options) {
+    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/market/${encodeURIComponent(options.skillId)}`);
+    const { body } = await fetchTextOrThrow(url, { headers: baseHeaders(options) });
+    return normalizeSkillId(unwrapEnvelope(body));
+}
 export async function deleteSkill(options) {
     const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/${encodeURIComponent(options.skillId)}`);
     const { body } = await fetchTextOrThrow(url, { method: "DELETE", headers: baseHeaders(options) });
@@ -101,14 +106,49 @@ export async function updateSkillStatus(options) {
     });
     return normalizeSkillId(unwrapEnvelope(body));
 }
+export async function updateSkillMetadata(options) {
+    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/${encodeURIComponent(options.skillId)}/metadata`);
+    const payload = {
+        name: options.name,
+        description: options.description,
+        category: options.category,
+    };
+    if (options.source)
+        payload.source = options.source;
+    if (options.extendInfo)
+        payload.extend_info = options.extendInfo;
+    const { body } = await fetchTextOrThrow(url, {
+        method: "PUT",
+        headers: { ...baseHeaders(options), "content-type": "application/json" },
+        body: JSON.stringify(payload),
+    });
+    return normalizeSkillId(unwrapEnvelope(body));
+}
 export async function registerSkillContent(options) {
+    // Backend's file_type=content path is half-implemented: it stores
+    // the markdown body but skips skill_file_index, so the skill is
+    // unreadable after publish (GET /skills/:id/content -> 404).
+    // Bundle the content into a 1-file SKILL.md zip and route through
+    // the zip path, which writes skill_file_index correctly.
+    const { default: JSZip } = await import("jszip");
+    const zip = new JSZip();
+    zip.file("SKILL.md", options.content);
+    const bytes = new Uint8Array(await zip.generateAsync({ type: "uint8array", compression: "DEFLATE" }));
+    return registerSkillZip({
+        baseUrl: options.baseUrl,
+        accessToken: options.accessToken,
+        businessDomain: options.businessDomain,
+        filename: "SKILL.md.zip",
+        bytes,
+        source: options.source,
+        extendInfo: options.extendInfo,
+    });
+}
+export async function registerSkillZip(options) {
     const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills`);
     const form = new FormData();
-    form.set("file_type", "content");
-    // Backend's gin form-binder rejects plain string field for `file`
-    // (typed json.RawMessage); needs an actual multipart file part with
-    // filename. See utils/gin.go GetBindMultipartFormRaw.
-    form.set("file", new Blob([options.content], { type: "text/markdown" }), "SKILL.md");
+    form.set("file_type", "zip");
+    form.set("file", new Blob([Buffer.from(options.bytes)]), options.filename);
     if (options.source)
         form.set("source", options.source);
     if (options.extendInfo)
@@ -120,17 +160,22 @@ export async function registerSkillContent(options) {
     });
     return normalizeSkillId(unwrapEnvelope(body));
 }
-export async function registerSkillZip(options) {
-    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills`);
+export async function updateSkillPackageContent(options) {
+    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/${encodeURIComponent(options.skillId)}/package`);
+    const { body } = await fetchTextOrThrow(url, {
+        method: "PUT",
+        headers: { ...baseHeaders(options), "content-type": "application/json" },
+        body: JSON.stringify({ file_type: "content", file: options.content }),
+    });
+    return normalizeSkillId(unwrapEnvelope(body));
+}
+export async function updateSkillPackageZip(options) {
+    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/${encodeURIComponent(options.skillId)}/package`);
     const form = new FormData();
     form.set("file_type", "zip");
     form.set("file", new Blob([Buffer.from(options.bytes)]), options.filename);
-    if (options.source)
-        form.set("source", options.source);
-    if (options.extendInfo)
-        form.set("extend_info", JSON.stringify(options.extendInfo));
     const { body } = await fetchTextOrThrow(url, {
-        method: "POST",
+        method: "PUT",
         headers: baseHeaders(options),
         body: form,
     });
@@ -169,6 +214,57 @@ export async function downloadSkill(options) {
         bytes: body,
     };
 }
+export async function listSkillHistory(options) {
+    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/${encodeURIComponent(options.skillId)}/history`);
+    const { body } = await fetchTextOrThrow(url, { headers: baseHeaders(options) });
+    return normalizeSkillId(unwrapEnvelope(body));
+}
+export async function republishSkillHistory(options) {
+    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/${encodeURIComponent(options.skillId)}/history/republish`);
+    const { body } = await fetchTextOrThrow(url, {
+        method: "POST",
+        headers: { ...baseHeaders(options), "content-type": "application/json" },
+        body: JSON.stringify({ version: options.version }),
+    });
+    return normalizeSkillId(unwrapEnvelope(body));
+}
+export async function publishSkillHistory(options) {
+    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/${encodeURIComponent(options.skillId)}/history/publish`);
+    const { body } = await fetchTextOrThrow(url, {
+        method: "POST",
+        headers: { ...baseHeaders(options), "content-type": "application/json" },
+        body: JSON.stringify({ version: options.version }),
+    });
+    return normalizeSkillId(unwrapEnvelope(body));
+}
+// ── Management Content (editing-state) API ───────────────────────────────────
+export async function getSkillManagementContent(options) {
+    const url = new URL(buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/${encodeURIComponent(options.skillId)}/management/content`));
+    if (options.responseMode)
+        url.searchParams.set("response_mode", options.responseMode);
+    const { body } = await fetchTextOrThrow(url, { headers: baseHeaders(options) });
+    return unwrapEnvelope(body);
+}
+export async function readSkillManagementFile(options) {
+    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/${encodeURIComponent(options.skillId)}/management/files/read`);
+    const { body } = await fetchTextOrThrow(url, {
+        method: "POST",
+        headers: { ...baseHeaders(options), "content-type": "application/json" },
+        body: JSON.stringify({ rel_path: options.relPath }),
+    });
+    return normalizeSkillId(unwrapEnvelope(body));
+}
+export async function downloadSkillManagementArchive(options) {
+    const url = new URL(buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/${encodeURIComponent(options.skillId)}/management/download`));
+    if (options.responseMode)
+        url.searchParams.set("response_mode", options.responseMode);
+    const { response, body } = await fetchBytesOrThrow(url, { headers: baseHeaders(options) });
+    const serverName = parseContentDisposition(response.headers.get("content-disposition"));
+    return {
+        fileName: basename(serverName || `${options.skillId}.zip`),
+        bytes: body,
+    };
+}
 export function installSkillArchive(options) {
     const targetDir = resolve(options.directory);
     const existed = existsSync(targetDir);

package/dist/api/trace.d.ts

@@ -25,6 +25,11 @@ export interface RawSpan {
         code?: string;
     };
     attributes?: Record<string, unknown>;
+    events?: Array<{
+        name?: string;
+        time?: string;
+        attributes?: Record<string, unknown>;
+    }>;
     /** OTel traceId for the trace this span belongs to (when known). */
     traceId?: string;
 }

package/dist/api/trace.js

@@ -48,6 +48,9 @@ function normalizeToRawSpan(source) {
         endTimeUnixNano = isoToNanos(source.endTime);
     const status = source.status;
     const attributes = source.attributes;
+    const events = Array.isArray(source.events)
+        ? source.events
+        : undefined;
     const name = typeof source.name === "string" ? source.name : undefined;
     const traceIdRaw = source.traceId ?? source.trace_id;
     const traceId = typeof traceIdRaw === "string" ? traceIdRaw : undefined;
@@ -59,6 +62,7 @@ function normalizeToRawSpan(source) {
         endTimeUnixNano,
         status,
         attributes,
+        events,
         traceId,
     };
 }