@prefactor/sdk 0.1.3 → 0.1.4

package/dist/index.js

@@ -1,1256 +1,5 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+// packages/sdk/src/index.ts
+export * from "@prefactor/core";
+export * from "@prefactor/langchain";
 
-// node_modules/@prefactor/pfid/dist/errors.js
-var require_errors = __commonJS((exports) => {
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.PfidError = undefined;
-
-  class PfidError extends Error {
-    constructor(code, message) {
-      super(message);
-      this.name = "PfidError";
-      this.code = code;
-      Object.setPrototypeOf(this, PfidError.prototype);
-    }
-    static make(code, problem) {
-      const message = (() => {
-        switch (code) {
-          case "invalid_binary":
-            return `invalid binary PFID: ${JSON.stringify(problem)}`;
-          case "invalid_pfid":
-            return `invalid PFID: ${JSON.stringify(problem)}`;
-          case "invalid_partition":
-            return `invalid partition: ${JSON.stringify(problem)}`;
-        }
-      })();
-      return new PfidError(code, message);
-    }
-  }
-  exports.PfidError = PfidError;
-});
-
-// node_modules/@prefactor/pfid/dist/pfid.js
-var require_pfid = __commonJS((exports) => {
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.zero = zero;
-  exports.generate = generate;
-  exports.generateWithTimestamp = generateWithTimestamp;
-  exports.generateExample = generateExample;
-  exports.generateRelated = generateRelated;
-  exports.generateRoot = generateRoot;
-  exports.generateBinary = generateBinary;
-  exports.generateBinaryWithTimestamp = generateBinaryWithTimestamp;
-  exports.isPfid = isPfid;
-  exports.encode = encode;
-  exports.decode = decode;
-  exports.extractPartition = extractPartition;
-  exports.generatePartition = generatePartition;
-  var crypto_1 = __require("crypto");
-  var errors_1 = require_errors();
-  var MAX_TIMESTAMP = 281474976710655;
-  var MAX_PARTITION = 1073741823;
-  var ENCODE_CHARS = "0123456789abcdefghjkmnpqrstvwxyz";
-  var DECODE_MAP = {
-    "0": 0,
-    "1": 1,
-    "2": 2,
-    "3": 3,
-    "4": 4,
-    "5": 5,
-    "6": 6,
-    "7": 7,
-    "8": 8,
-    "9": 9,
-    a: 10,
-    b: 11,
-    c: 12,
-    d: 13,
-    e: 14,
-    f: 15,
-    g: 16,
-    h: 17,
-    j: 18,
-    k: 19,
-    m: 20,
-    n: 21,
-    p: 22,
-    q: 23,
-    r: 24,
-    s: 25,
-    t: 26,
-    v: 27,
-    w: 28,
-    x: 29,
-    y: 30,
-    z: 31
-  };
-  function encodeChar(value) {
-    return ENCODE_CHARS[value];
-  }
-  function decodeChar(char) {
-    const value = DECODE_MAP[char.toLowerCase()];
-    if (value === undefined) {
-      throw new Error(`Invalid character: ${char}`);
-    }
-    return value;
-  }
-  function isValidTimestamp(timestamp) {
-    return Number.isInteger(timestamp) && timestamp >= 0 && timestamp <= MAX_TIMESTAMP;
-  }
-  function isValidPartition(partition) {
-    return Number.isInteger(partition) && partition >= 0 && partition <= MAX_PARTITION;
-  }
-  function zero() {
-    return "00000000000000000000000000000000";
-  }
-  function generate(partition) {
-    if (!isValidPartition(partition)) {
-      throw new Error(`Invalid partition: ${partition}`);
-    }
-    return unsafeEncode(generateBinary(partition));
-  }
-  function generateWithTimestamp(partition, timestamp) {
-    if (!isValidPartition(partition)) {
-      throw new Error(`Invalid partition: ${partition}`);
-    }
-    if (!isValidTimestamp(timestamp)) {
-      throw new Error(`Invalid timestamp: ${timestamp}`);
-    }
-    return unsafeEncode(generateBinaryWithTimestamp(partition, timestamp));
-  }
-  function generateExample() {
-    return generateWithTimestamp(123456789, 1234567890000);
-  }
-  function generateRelated(existingPfid) {
-    return generate(extractPartition(existingPfid));
-  }
-  function generateRoot() {
-    return generate(generatePartition());
-  }
-  function generateBinary(partition) {
-    if (!isValidPartition(partition)) {
-      throw new Error(`Invalid partition: ${partition}`);
-    }
-    const timestamp = Date.now();
-    return generateBinaryWithTimestamp(partition, timestamp);
-  }
-  function generateBinaryWithTimestamp(partition, timestamp) {
-    if (!isValidPartition(partition)) {
-      throw new Error(`Invalid partition: ${partition}`);
-    }
-    if (!isValidTimestamp(timestamp)) {
-      throw new Error(`Invalid timestamp: ${timestamp}`);
-    }
-    const buffer = Buffer.allocUnsafe(20);
-    buffer[0] = Math.floor(timestamp / 1099511627776) & 255;
-    buffer[1] = Math.floor(timestamp / 4294967296) & 255;
-    buffer[2] = timestamp >> 24 & 255;
-    buffer[3] = timestamp >> 16 & 255;
-    buffer[4] = timestamp >> 8 & 255;
-    buffer[5] = timestamp & 255;
-    buffer.writeUInt32BE(partition, 6);
-    (0, crypto_1.randomBytes)(10).copy(buffer, 10);
-    return buffer;
-  }
-  function isPfid(string) {
-    if (typeof string !== "string") {
-      return false;
-    }
-    if (string.length !== 32) {
-      return false;
-    }
-    if (string[0] < "0" || string[0] > "7") {
-      return false;
-    }
-    const validPattern = /^[0-7][0-9abcdefghjkmnpqrstvwxyz]{31}$/;
-    return validPattern.test(string);
-  }
-  function encode(binary) {
-    if (!Buffer.isBuffer(binary) || binary.length !== 20) {
-      throw errors_1.PfidError.make("invalid_binary", binary);
-    }
-    try {
-      const encoded = unsafeEncode(binary);
-      if (isPfid(encoded)) {
-        return encoded;
-      } else {
-        throw errors_1.PfidError.make("invalid_binary", binary);
-      }
-    } catch (error) {
-      if (error instanceof errors_1.PfidError) {
-        throw error;
-      }
-      throw errors_1.PfidError.make("invalid_binary", binary);
-    }
-  }
-  function decode(pfid) {
-    if (typeof pfid !== "string" || pfid.length !== 32) {
-      throw errors_1.PfidError.make("invalid_pfid", pfid);
-    }
-    if (pfid[0] < "0" || pfid[0] > "7") {
-      throw errors_1.PfidError.make("invalid_pfid", pfid);
-    }
-    try {
-      return unsafeDecode(pfid);
-    } catch (error) {
-      if (error instanceof errors_1.PfidError) {
-        throw error;
-      }
-      throw errors_1.PfidError.make("invalid_pfid", pfid);
-    }
-  }
-  function extractPartition(pfid) {
-    if (!isPfid(pfid)) {
-      throw errors_1.PfidError.make("invalid_pfid", pfid);
-    }
-    try {
-      const partitionStr = pfid.substring(10, 16);
-      return decodePartition(partitionStr);
-    } catch (error) {
-      if (error instanceof errors_1.PfidError) {
-        throw error;
-      }
-      throw errors_1.PfidError.make("invalid_pfid", pfid);
-    }
-  }
-  function generatePartition() {
-    const buffer = (0, crypto_1.randomBytes)(4);
-    buffer[0] = buffer[0] & 63;
-    const partition = buffer.readUInt32BE(0) & 1073741823;
-    return partition;
-  }
-  function unsafeEncode(binary) {
-    let bitOffset = 0;
-    function readBits(count) {
-      let value = 0;
-      for (let i = 0;i < count; i++) {
-        const byteIndex = Math.floor(bitOffset / 8);
-        const bitIndex = 7 - bitOffset % 8;
-        const bit = binary[byteIndex] >> bitIndex & 1;
-        value = value << 1 | bit;
-        bitOffset++;
-      }
-      return value;
-    }
-    const t1 = readBits(3);
-    const t2 = readBits(5);
-    const t3 = readBits(5);
-    const t4 = readBits(5);
-    const t5 = readBits(5);
-    const t6 = readBits(5);
-    const t7 = readBits(5);
-    const t8 = readBits(5);
-    const t9 = readBits(5);
-    const t10 = readBits(5);
-    readBits(2);
-    const p1 = readBits(5);
-    const p2 = readBits(5);
-    const p3 = readBits(5);
-    const p4 = readBits(5);
-    const p5 = readBits(5);
-    const p6 = readBits(5);
-    const r1 = readBits(5);
-    const r2 = readBits(5);
-    const r3 = readBits(5);
-    const r4 = readBits(5);
-    const r5 = readBits(5);
-    const r6 = readBits(5);
-    const r7 = readBits(5);
-    const r8 = readBits(5);
-    const r9 = readBits(5);
-    const r10 = readBits(5);
-    const r11 = readBits(5);
-    const r12 = readBits(5);
-    const r13 = readBits(5);
-    const r14 = readBits(5);
-    const r15 = readBits(5);
-    const r16 = readBits(5);
-    return encodeChar(t1) + encodeChar(t2) + encodeChar(t3) + encodeChar(t4) + encodeChar(t5) + encodeChar(t6) + encodeChar(t7) + encodeChar(t8) + encodeChar(t9) + encodeChar(t10) + encodeChar(p1) + encodeChar(p2) + encodeChar(p3) + encodeChar(p4) + encodeChar(p5) + encodeChar(p6) + encodeChar(r1) + encodeChar(r2) + encodeChar(r3) + encodeChar(r4) + encodeChar(r5) + encodeChar(r6) + encodeChar(r7) + encodeChar(r8) + encodeChar(r9) + encodeChar(r10) + encodeChar(r11) + encodeChar(r12) + encodeChar(r13) + encodeChar(r14) + encodeChar(r15) + encodeChar(r16);
-  }
-  function unsafeDecode(pfid) {
-    const t1 = decodeChar(pfid[0]);
-    const t2 = decodeChar(pfid[1]);
-    const t3 = decodeChar(pfid[2]);
-    const t4 = decodeChar(pfid[3]);
-    const t5 = decodeChar(pfid[4]);
-    const t6 = decodeChar(pfid[5]);
-    const t7 = decodeChar(pfid[6]);
-    const t8 = decodeChar(pfid[7]);
-    const t9 = decodeChar(pfid[8]);
-    const t10 = decodeChar(pfid[9]);
-    const p1 = decodeChar(pfid[10]);
-    const p2 = decodeChar(pfid[11]);
-    const p3 = decodeChar(pfid[12]);
-    const p4 = decodeChar(pfid[13]);
-    const p5 = decodeChar(pfid[14]);
-    const p6 = decodeChar(pfid[15]);
-    const r1 = decodeChar(pfid[16]);
-    const r2 = decodeChar(pfid[17]);
-    const r3 = decodeChar(pfid[18]);
-    const r4 = decodeChar(pfid[19]);
-    const r5 = decodeChar(pfid[20]);
-    const r6 = decodeChar(pfid[21]);
-    const r7 = decodeChar(pfid[22]);
-    const r8 = decodeChar(pfid[23]);
-    const r9 = decodeChar(pfid[24]);
-    const r10 = decodeChar(pfid[25]);
-    const r11 = decodeChar(pfid[26]);
-    const r12 = decodeChar(pfid[27]);
-    const r13 = decodeChar(pfid[28]);
-    const r14 = decodeChar(pfid[29]);
-    const r15 = decodeChar(pfid[30]);
-    const r16 = decodeChar(pfid[31]);
-    const buffer = Buffer.alloc(20, 0);
-    let bitOffset = 0;
-    function writeBits(value, count) {
-      for (let i = count - 1;i >= 0; i--) {
-        const byteIndex = Math.floor(bitOffset / 8);
-        const bitIndex = 7 - bitOffset % 8;
-        const bit = value >> i & 1;
-        buffer[byteIndex] |= bit << bitIndex;
-        bitOffset++;
-      }
-    }
-    writeBits(t1, 3);
-    writeBits(t2, 5);
-    writeBits(t3, 5);
-    writeBits(t4, 5);
-    writeBits(t5, 5);
-    writeBits(t6, 5);
-    writeBits(t7, 5);
-    writeBits(t8, 5);
-    writeBits(t9, 5);
-    writeBits(t10, 5);
-    writeBits(0, 2);
-    writeBits(p1, 5);
-    writeBits(p2, 5);
-    writeBits(p3, 5);
-    writeBits(p4, 5);
-    writeBits(p5, 5);
-    writeBits(p6, 5);
-    writeBits(r1, 5);
-    writeBits(r2, 5);
-    writeBits(r3, 5);
-    writeBits(r4, 5);
-    writeBits(r5, 5);
-    writeBits(r6, 5);
-    writeBits(r7, 5);
-    writeBits(r8, 5);
-    writeBits(r9, 5);
-    writeBits(r10, 5);
-    writeBits(r11, 5);
-    writeBits(r12, 5);
-    writeBits(r13, 5);
-    writeBits(r14, 5);
-    writeBits(r15, 5);
-    writeBits(r16, 5);
-    return buffer;
-  }
-  function decodePartition(partitionStr) {
-    if (typeof partitionStr !== "string" || partitionStr.length !== 6) {
-      throw errors_1.PfidError.make("invalid_partition", partitionStr);
-    }
-    try {
-      const p1 = decodeChar(partitionStr[0]);
-      const p2 = decodeChar(partitionStr[1]);
-      const p3 = decodeChar(partitionStr[2]);
-      const p4 = decodeChar(partitionStr[3]);
-      const p5 = decodeChar(partitionStr[4]);
-      const p6 = decodeChar(partitionStr[5]);
-      const buffer = Buffer.allocUnsafe(4);
-      buffer[0] = 0 << 6 | p1 << 1 | p2 >> 4;
-      buffer[1] = (p2 & 15) << 4 | p3 >> 1;
-      buffer[2] = (p3 & 1) << 7 | p4 << 2 | p5 >> 3;
-      buffer[3] = (p5 & 7) << 5 | p6 >> 0;
-      const partition = buffer.readUInt32BE(0) & 1073741823;
-      return partition;
-    } catch (error) {
-      if (error instanceof errors_1.PfidError) {
-        throw error;
-      }
-      throw errors_1.PfidError.make("invalid_partition", partitionStr);
-    }
-  }
-});
-
-// node_modules/@prefactor/pfid/dist/index.js
-var require_dist = __commonJS((exports) => {
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.PfidError = exports.generatePartition = exports.extractPartition = exports.decode = exports.encode = exports.isPfid = exports.generateBinaryWithTimestamp = exports.generateBinary = exports.generateRoot = exports.generateRelated = exports.generateExample = exports.generateWithTimestamp = exports.generate = exports.zero = undefined;
-  var pfid_1 = require_pfid();
-  Object.defineProperty(exports, "zero", { enumerable: true, get: function() {
-    return pfid_1.zero;
-  } });
-  Object.defineProperty(exports, "generate", { enumerable: true, get: function() {
-    return pfid_1.generate;
-  } });
-  Object.defineProperty(exports, "generateWithTimestamp", { enumerable: true, get: function() {
-    return pfid_1.generateWithTimestamp;
-  } });
-  Object.defineProperty(exports, "generateExample", { enumerable: true, get: function() {
-    return pfid_1.generateExample;
-  } });
-  Object.defineProperty(exports, "generateRelated", { enumerable: true, get: function() {
-    return pfid_1.generateRelated;
-  } });
-  Object.defineProperty(exports, "generateRoot", { enumerable: true, get: function() {
-    return pfid_1.generateRoot;
-  } });
-  Object.defineProperty(exports, "generateBinary", { enumerable: true, get: function() {
-    return pfid_1.generateBinary;
-  } });
-  Object.defineProperty(exports, "generateBinaryWithTimestamp", { enumerable: true, get: function() {
-    return pfid_1.generateBinaryWithTimestamp;
-  } });
-  Object.defineProperty(exports, "isPfid", { enumerable: true, get: function() {
-    return pfid_1.isPfid;
-  } });
-  Object.defineProperty(exports, "encode", { enumerable: true, get: function() {
-    return pfid_1.encode;
-  } });
-  Object.defineProperty(exports, "decode", { enumerable: true, get: function() {
-    return pfid_1.decode;
-  } });
-  Object.defineProperty(exports, "extractPartition", { enumerable: true, get: function() {
-    return pfid_1.extractPartition;
-  } });
-  Object.defineProperty(exports, "generatePartition", { enumerable: true, get: function() {
-    return pfid_1.generatePartition;
-  } });
-  var errors_1 = require_errors();
-  Object.defineProperty(exports, "PfidError", { enumerable: true, get: function() {
-    return errors_1.PfidError;
-  } });
-});
-
-// src/index.ts
-var import_pfid2 = __toESM(require_dist(), 1);
-
-// src/tracing/tracer.ts
-var import_pfid = __toESM(require_dist(), 1);
-
-// src/tracing/span.ts
-var SpanType;
-((SpanType2) => {
-  SpanType2["AGENT"] = "agent";
-  SpanType2["LLM"] = "llm";
-  SpanType2["TOOL"] = "tool";
-  SpanType2["CHAIN"] = "chain";
-  SpanType2["RETRIEVER"] = "retriever";
-})(SpanType ||= {});
-var SpanStatus;
-((SpanStatus2) => {
-  SpanStatus2["RUNNING"] = "running";
-  SpanStatus2["SUCCESS"] = "success";
-  SpanStatus2["ERROR"] = "error";
-})(SpanStatus ||= {});
-
-// src/tracing/tracer.ts
-class Tracer {
-  transport;
-  partition;
-  constructor(transport, partition) {
-    this.transport = transport;
-    this.partition = partition ?? import_pfid.generatePartition();
-  }
-  startSpan(options) {
-    const spanId = import_pfid.generate(this.partition);
-    const traceId = options.traceId ?? import_pfid.generate(this.partition);
-    const span = {
-      spanId,
-      parentSpanId: options.parentSpanId ?? null,
-      traceId,
-      name: options.name,
-      spanType: options.spanType,
-      startTime: Date.now(),
-      endTime: null,
-      status: "running" /* RUNNING */,
-      inputs: options.inputs,
-      outputs: null,
-      tokenUsage: null,
-      error: null,
-      metadata: options.metadata ?? {},
-      tags: options.tags ?? []
-    };
-    if (options.spanType === "agent") {
-      try {
-        this.transport.emit(span);
-      } catch (error) {
-        console.error("Failed to emit agent span:", error);
-      }
-    }
-    return span;
-  }
-  endSpan(span, options) {
-    span.endTime = Date.now();
-    span.outputs = options?.outputs ?? null;
-    span.tokenUsage = options?.tokenUsage ?? null;
-    if (options?.error) {
-      span.status = "error" /* ERROR */;
-      span.error = {
-        errorType: options.error.constructor.name,
-        message: options.error.message,
-        stacktrace: options.error.stack ?? ""
-      };
-    } else {
-      span.status = "success" /* SUCCESS */;
-    }
-    try {
-      if (span.spanType === "agent") {
-        this.transport.finishSpan(span.spanId, span.endTime);
-      } else {
-        this.transport.emit(span);
-      }
-    } catch (error) {
-      console.error("Failed to emit/finish span:", error);
-    }
-  }
-  startAgentInstance() {
-    try {
-      this.transport.startAgentInstance();
-    } catch (error) {
-      console.error("Failed to start agent instance:", error);
-    }
-  }
-  finishAgentInstance() {
-    try {
-      this.transport.finishAgentInstance();
-    } catch (error) {
-      console.error("Failed to finish agent instance:", error);
-    }
-  }
-  async close() {
-    try {
-      await this.transport.close();
-    } catch (error) {
-      console.error("Failed to close transport:", error);
-    }
-  }
-}
-
-// src/tracing/context.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-var spanStorage = new AsyncLocalStorage;
-
-class SpanContext {
-  static getCurrent() {
-    return spanStorage.getStore();
-  }
-  static run(span, fn) {
-    return spanStorage.run(span, fn);
-  }
-  static async runAsync(span, fn) {
-    return spanStorage.run(span, fn);
-  }
-  static clear() {
-    spanStorage.disable();
-  }
-}
-
-// src/instrumentation/langchain/metadata-extractor.ts
-function extractTokenUsage(response) {
-  try {
-    const tokenUsage = response?.token_usage ?? response?.usage;
-    if (tokenUsage) {
-      return {
-        promptTokens: tokenUsage.prompt_tokens ?? 0,
-        completionTokens: tokenUsage.completion_tokens ?? 0,
-        totalTokens: tokenUsage.total_tokens ?? 0
-      };
-    }
-    const usageMetadata = response?.usage_metadata;
-    if (usageMetadata) {
-      return {
-        promptTokens: usageMetadata.input_tokens ?? 0,
-        completionTokens: usageMetadata.output_tokens ?? 0,
-        totalTokens: usageMetadata.total_tokens ?? 0
-      };
-    }
-    const responseMetadata = response?.response_metadata;
-    if (responseMetadata?.token_usage) {
-      return {
-        promptTokens: responseMetadata.token_usage.prompt_tokens ?? 0,
-        completionTokens: responseMetadata.token_usage.completion_tokens ?? 0,
-        totalTokens: responseMetadata.token_usage.total_tokens ?? 0
-      };
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-// src/instrumentation/langchain/middleware.ts
-class PrefactorMiddleware {
-  tracer;
-  rootSpan = null;
-  constructor(tracer) {
-    this.tracer = tracer;
-  }
-  async beforeAgent(state) {
-    const parentSpan = SpanContext.getCurrent();
-    const messages = state?.messages ?? [];
-    this.tracer.startAgentInstance();
-    const span = this.tracer.startSpan({
-      name: "agent",
-      spanType: "agent" /* AGENT */,
-      inputs: { messages: messages.slice(-3).map((m) => String(m)) },
-      parentSpanId: parentSpan?.spanId,
-      traceId: parentSpan?.traceId
-    });
-    this.rootSpan = span;
-  }
-  async afterAgent(state) {
-    if (!this.rootSpan) {
-      return;
-    }
-    const messages = state?.messages ?? [];
-    this.tracer.endSpan(this.rootSpan, {
-      outputs: { messages: messages.slice(-3).map((m) => String(m)) }
-    });
-    this.tracer.finishAgentInstance();
-    SpanContext.clear();
-    this.rootSpan = null;
-  }
-  async wrapModelCall(request, handler) {
-    const parentSpan = SpanContext.getCurrent();
-    const span = this.tracer.startSpan({
-      name: this.extractModelName(request),
-      spanType: "llm" /* LLM */,
-      inputs: this.extractModelInputs(request),
-      parentSpanId: parentSpan?.spanId,
-      traceId: parentSpan?.traceId
-    });
-    try {
-      const response = await SpanContext.runAsync(span, async () => {
-        return handler(request);
-      });
-      const outputs = this.extractModelOutputs(response);
-      const tokenUsage = extractTokenUsage(response);
-      this.tracer.endSpan(span, { outputs, tokenUsage: tokenUsage ?? undefined });
-      return response;
-    } catch (error) {
-      this.tracer.endSpan(span, { error });
-      throw error;
-    }
-  }
-  async wrapToolCall(request, handler) {
-    const parentSpan = SpanContext.getCurrent();
-    const span = this.tracer.startSpan({
-      name: this.extractToolName(request),
-      spanType: "tool" /* TOOL */,
-      inputs: this.extractToolInputs(request),
-      parentSpanId: parentSpan?.spanId,
-      traceId: parentSpan?.traceId
-    });
-    try {
-      const response = await SpanContext.runAsync(span, async () => {
-        return handler(request);
-      });
-      this.tracer.endSpan(span, {
-        outputs: this.extractToolOutputs(response)
-      });
-      return response;
-    } catch (error) {
-      this.tracer.endSpan(span, { error });
-      throw error;
-    }
-  }
-  extractModelName(request) {
-    return request?.model ?? request?.modelName ?? "unknown";
-  }
-  extractModelInputs(request) {
-    const messages = request?.messages ?? [];
-    return { messages: messages.slice(-3).map((m) => String(m)) };
-  }
-  extractModelOutputs(response) {
-    const content = response?.content ?? response?.text ?? "";
-    return { content: String(content) };
-  }
-  extractToolName(request) {
-    return request?.name ?? request?.tool ?? "unknown";
-  }
-  extractToolInputs(request) {
-    return { input: request?.input ?? request?.args ?? {} };
-  }
-  extractToolOutputs(response) {
-    return { output: response?.output ?? response };
-  }
-}
-
-// src/utils/serialization.ts
-function truncateString(value, maxLength) {
-  if (value.length <= maxLength) {
-    return value;
-  }
-  return value.slice(0, maxLength) + "... [truncated]";
-}
-function serializeValue(value, maxLength = 1e4) {
-  if (value === null || value === undefined) {
-    return value;
-  }
-  if (typeof value === "boolean" || typeof value === "number") {
-    return value;
-  }
-  if (typeof value === "string") {
-    return maxLength !== null ? truncateString(value, maxLength) : value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => serializeValue(item, maxLength));
-  }
-  if (typeof value === "object") {
-    const result = {};
-    for (const [key, val] of Object.entries(value)) {
-      result[key] = serializeValue(val, maxLength);
-    }
-    return result;
-  }
-  try {
-    return String(value);
-  } catch {
-    return `<${typeof value} object>`;
-  }
-}
-
-// src/transport/stdio.ts
-class StdioTransport {
-  closed = false;
-  writeLock = Promise.resolve();
-  emit(span) {
-    if (this.closed) {
-      return;
-    }
-    this.writeLock = this.writeLock.then(async () => {
-      try {
-        const serialized = serializeValue(span);
-        const json = JSON.stringify(serialized);
-        await Bun.write(Bun.stdout, json + `
-`);
-      } catch (error) {
-        console.error("Failed to emit span to stdout:", error);
-      }
-    });
-  }
-  finishSpan() {}
-  startAgentInstance() {}
-  finishAgentInstance() {}
-  async close() {
-    this.closed = true;
-    await this.writeLock;
-  }
-}
-
-// src/utils/logging.ts
-class Logger {
-  namespace;
-  static level = 1 /* INFO */;
-  constructor(namespace) {
-    this.namespace = namespace;
-  }
-  debug(message, ...args) {
-    if (Logger.level <= 0 /* DEBUG */) {
-      console.debug(`[prefactor:${this.namespace}] ${message}`, ...args);
-    }
-  }
-  info(message, ...args) {
-    if (Logger.level <= 1 /* INFO */) {
-      console.info(`[prefactor:${this.namespace}] ${message}`, ...args);
-    }
-  }
-  warn(message, ...args) {
-    if (Logger.level <= 2 /* WARN */) {
-      console.warn(`[prefactor:${this.namespace}] ${message}`, ...args);
-    }
-  }
-  error(message, ...args) {
-    if (Logger.level <= 3 /* ERROR */) {
-      console.error(`[prefactor:${this.namespace}] ${message}`, ...args);
-    }
-  }
-  static setLevel(level) {
-    const levelMap = {
-      debug: 0 /* DEBUG */,
-      info: 1 /* INFO */,
-      warn: 2 /* WARN */,
-      error: 3 /* ERROR */
-    };
-    Logger.level = levelMap[level];
-  }
-}
-function getLogger(namespace) {
-  return new Logger(namespace);
-}
-function configureLogging() {
-  const level = process.env.PREFACTOR_LOG_LEVEL?.toLowerCase();
-  if (level) {
-    Logger.setLevel(level);
-  }
-}
-
-// src/transport/http.ts
-var logger = getLogger("http-transport");
-
-class HttpTransport {
-  config;
-  queue = [];
-  processing = false;
-  closed = false;
-  agentInstanceId = null;
-  spanIdMap = new Map;
-  constructor(config) {
-    this.config = config;
-    this.startProcessing();
-  }
-  emit(span) {
-    if (this.closed) {
-      return;
-    }
-    this.queue.push({ type: "span", data: span });
-  }
-  finishSpan(spanId, endTime) {
-    if (this.closed) {
-      return;
-    }
-    const timestamp = new Date(endTime).toISOString();
-    this.queue.push({ type: "finish_span", data: { spanId, timestamp } });
-  }
-  startAgentInstance() {
-    if (this.closed) {
-      return;
-    }
-    this.queue.push({ type: "start_agent", data: null });
-  }
-  finishAgentInstance() {
-    if (this.closed) {
-      return;
-    }
-    this.queue.push({ type: "finish_agent", data: null });
-  }
-  async startProcessing() {
-    this.processing = true;
-    while (!this.closed || this.queue.length > 0) {
-      if (this.queue.length === 0) {
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        continue;
-      }
-      const item = this.queue.shift();
-      try {
-        if (!this.agentInstanceId && item.type !== "start_agent") {
-          await this.ensureAgentRegistered();
-        }
-        switch (item.type) {
-          case "span":
-            await this.sendSpan(item.data);
-            break;
-          case "finish_span":
-            await this.finishSpanHttp(item.data);
-            break;
-          case "start_agent":
-            await this.startAgentInstanceHttp();
-            break;
-          case "finish_agent":
-            await this.finishAgentInstanceHttp();
-            break;
-        }
-      } catch (error) {
-        logger.error("Error processing queue item:", error);
-      }
-    }
-    this.processing = false;
-  }
-  async sendSpan(span, retry = 0) {
-    const url = `${this.config.apiUrl}/api/v1/agent_spans`;
-    const payload = this.transformSpanToApiFormat(span);
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${this.config.apiToken}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(payload),
-        signal: AbortSignal.timeout(this.config.requestTimeout)
-      });
-      if (response.ok) {
-        const data = await response.json();
-        const backendSpanId = data?.details?.id;
-        if (backendSpanId) {
-          this.spanIdMap.set(span.spanId, backendSpanId);
-        }
-        return;
-      }
-      if ((response.status >= 500 || response.status === 429) && retry < this.config.maxRetries) {
-        const delay = Math.min(this.config.initialRetryDelay * Math.pow(this.config.retryMultiplier, retry), this.config.maxRetryDelay);
-        logger.debug(`Retrying span send after ${delay}ms (attempt ${retry + 1})`);
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        return this.sendSpan(span, retry + 1);
-      }
-      logger.error(`Failed to send span: ${response.status} ${response.statusText}`);
-    } catch (error) {
-      logger.error("Error sending span:", error);
-      if (retry < this.config.maxRetries) {
-        const delay = Math.min(this.config.initialRetryDelay * Math.pow(this.config.retryMultiplier, retry), this.config.maxRetryDelay);
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        return this.sendSpan(span, retry + 1);
-      }
-    }
-  }
-  transformSpanToApiFormat(span) {
-    const startedAt = new Date(span.startTime).toISOString();
-    const finishedAt = span.endTime ? new Date(span.endTime).toISOString() : null;
-    const payload = {
-      span_id: span.spanId,
-      trace_id: span.traceId,
-      name: span.name,
-      status: span.status,
-      inputs: span.inputs,
-      outputs: span.outputs,
-      metadata: span.metadata,
-      tags: span.tags,
-      token_usage: null,
-      error: null
-    };
-    if (span.tokenUsage) {
-      payload.token_usage = {
-        prompt_tokens: span.tokenUsage.promptTokens,
-        completion_tokens: span.tokenUsage.completionTokens,
-        total_tokens: span.tokenUsage.totalTokens
-      };
-    }
-    if (span.error) {
-      payload.error = {
-        error_type: span.error.errorType,
-        message: span.error.message,
-        stacktrace: span.error.stacktrace
-      };
-    }
-    const parentSpanId = span.parentSpanId ? this.spanIdMap.get(span.parentSpanId) ?? null : null;
-    return {
-      details: {
-        agent_instance_id: this.agentInstanceId,
-        schema_name: span.spanType,
-        payload,
-        parent_span_id: parentSpanId,
-        started_at: startedAt,
-        finished_at: finishedAt
-      }
-    };
-  }
-  getDefaultSchema() {
-    return {
-      external_identifier: "1.0.0",
-      span_schemas: {
-        agent: {
-          type: "object",
-          properties: { type: { type: "string", const: "agent" } }
-        },
-        llm: {
-          type: "object",
-          properties: { type: { type: "string", const: "llm" } }
-        },
-        tool: {
-          type: "object",
-          properties: { type: { type: "string", const: "tool" } }
-        },
-        chain: {
-          type: "object",
-          properties: { type: { type: "string", const: "chain" } }
-        },
-        retriever: {
-          type: "object",
-          properties: { type: { type: "string", const: "retriever" } }
-        }
-      }
-    };
-  }
-  async ensureAgentRegistered() {
-    if (this.agentInstanceId) {
-      return;
-    }
-    const url = `${this.config.apiUrl}/api/v1/agent_instance/register`;
-    const payload = {};
-    if (this.config.agentId)
-      payload.agent_id = this.config.agentId;
-    if (this.config.agentVersion) {
-      payload.agent_version = {
-        external_identifier: this.config.agentVersion,
-        name: this.config.agentName || "Agent",
-        description: this.config.agentDescription || ""
-      };
-    }
-    if (this.config.skipSchema) {
-      logger.debug("Skipping schema in registration (skipSchema=true)");
-    } else if (this.config.agentSchema) {
-      logger.debug("Using custom agent schema");
-      payload.agent_schema_version = this.config.agentSchema;
-    } else if (this.config.agentSchemaVersion) {
-      logger.debug(`Using schema version: ${this.config.agentSchemaVersion}`);
-      payload.agent_schema_version = {
-        external_identifier: this.config.agentSchemaVersion
-      };
-    } else {
-      logger.debug("Using default hardcoded schema (v1.0.0)");
-      payload.agent_schema_version = this.getDefaultSchema();
-    }
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${this.config.apiToken}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(payload),
-        signal: AbortSignal.timeout(this.config.requestTimeout)
-      });
-      if (response.ok) {
-        const data = await response.json();
-        this.agentInstanceId = data?.details?.id ?? null;
-        logger.debug(`Registered agent instance: ${this.agentInstanceId}`);
-      } else {
-        logger.error(`Failed to register agent: ${response.status} ${response.statusText}`);
-      }
-    } catch (error) {
-      logger.error("Error registering agent:", error);
-    }
-  }
-  async startAgentInstanceHttp() {
-    await this.ensureAgentRegistered();
-    if (!this.agentInstanceId) {
-      logger.error("Cannot start agent instance: not registered");
-      return;
-    }
-    const url = `${this.config.apiUrl}/api/v1/agent_instance/${this.agentInstanceId}/start`;
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${this.config.apiToken}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({}),
-        signal: AbortSignal.timeout(this.config.requestTimeout)
-      });
-      if (!response.ok) {
-        logger.error(`Failed to start agent instance: ${response.status} ${response.statusText}`);
-      }
-    } catch (error) {
-      logger.error("Error starting agent instance:", error);
-    }
-  }
-  async finishAgentInstanceHttp() {
-    if (!this.agentInstanceId) {
-      logger.error("Cannot finish agent instance: not registered");
-      return;
-    }
-    const url = `${this.config.apiUrl}/api/v1/agent_instance/${this.agentInstanceId}/finish`;
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${this.config.apiToken}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({}),
-        signal: AbortSignal.timeout(this.config.requestTimeout)
-      });
-      if (!response.ok) {
-        logger.error(`Failed to finish agent instance: ${response.status} ${response.statusText}`);
-      }
-    } catch (error) {
-      logger.error("Error finishing agent instance:", error);
-    }
-  }
-  async finishSpanHttp(data) {
-    const backendSpanId = this.spanIdMap.get(data.spanId);
-    if (!backendSpanId) {
-      logger.warn(`Cannot finish span ${data.spanId}: backend ID not found`);
-      return;
-    }
-    const url = `${this.config.apiUrl}/api/v1/agent_spans/${backendSpanId}/finish`;
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${this.config.apiToken}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ timestamp: data.timestamp }),
-        signal: AbortSignal.timeout(this.config.requestTimeout)
-      });
-      if (!response.ok) {
-        logger.error(`Failed to finish span: ${response.status} ${response.statusText}`);
-      }
-    } catch (error) {
-      logger.error("Error finishing span:", error);
-    }
-  }
-  async close() {
-    this.closed = true;
-    const timeout = 1e4;
-    const start = Date.now();
-    while (this.processing && Date.now() - start < timeout) {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    if (this.processing) {
-      logger.warn("Transport closed with pending queue items");
-    }
-  }
-}
-
-// src/config.ts
-import { z } from "zod";
-var HttpTransportConfigSchema = z.object({
-  apiUrl: z.string().url(),
-  apiToken: z.string().min(1),
-  agentId: z.string().optional(),
-  agentVersion: z.string().optional(),
-  agentName: z.string().optional(),
-  agentDescription: z.string().optional(),
-  agentSchema: z.record(z.unknown()).optional(),
-  agentSchemaVersion: z.string().optional(),
-  skipSchema: z.boolean().default(false),
-  requestTimeout: z.number().positive().default(30000),
-  connectTimeout: z.number().positive().default(1e4),
-  maxRetries: z.number().int().nonnegative().default(3),
-  initialRetryDelay: z.number().positive().default(1000),
-  maxRetryDelay: z.number().positive().default(60000),
-  retryMultiplier: z.number().positive().default(2)
-});
-var PartialHttpConfigSchema = z.object({
-  apiUrl: z.string().url(),
-  apiToken: z.string().min(1),
-  agentId: z.string().optional(),
-  agentVersion: z.string().optional(),
-  agentName: z.string().optional(),
-  agentDescription: z.string().optional(),
-  agentSchema: z.record(z.unknown()).optional(),
-  agentSchemaVersion: z.string().optional(),
-  skipSchema: z.boolean().optional(),
-  requestTimeout: z.number().positive().optional(),
-  connectTimeout: z.number().positive().optional(),
-  maxRetries: z.number().int().nonnegative().optional(),
-  initialRetryDelay: z.number().positive().optional(),
-  maxRetryDelay: z.number().positive().optional(),
-  retryMultiplier: z.number().positive().optional()
-});
-var ConfigSchema = z.object({
-  transportType: z.enum(["stdio", "http"]).default("stdio"),
-  sampleRate: z.number().min(0).max(1).default(1),
-  captureInputs: z.boolean().default(true),
-  captureOutputs: z.boolean().default(true),
-  maxInputLength: z.number().int().positive().default(1e4),
-  maxOutputLength: z.number().int().positive().default(1e4),
-  httpConfig: PartialHttpConfigSchema.optional()
-});
-function createConfig(options) {
-  const config = {
-    transportType: options?.transportType ?? process.env.PREFACTOR_TRANSPORT ?? "stdio",
-    sampleRate: options?.sampleRate ?? parseFloat(process.env.PREFACTOR_SAMPLE_RATE ?? "1.0"),
-    captureInputs: options?.captureInputs ?? process.env.PREFACTOR_CAPTURE_INPUTS !== "false",
-    captureOutputs: options?.captureOutputs ?? process.env.PREFACTOR_CAPTURE_OUTPUTS !== "false",
-    maxInputLength: options?.maxInputLength ?? parseInt(process.env.PREFACTOR_MAX_INPUT_LENGTH ?? "10000", 10),
-    maxOutputLength: options?.maxOutputLength ?? parseInt(process.env.PREFACTOR_MAX_OUTPUT_LENGTH ?? "10000", 10),
-    httpConfig: options?.httpConfig
-  };
-  return ConfigSchema.parse(config);
-}
-
-// src/index.ts
-import { createMiddleware } from "langchain";
-var logger2 = getLogger("init");
-var globalTracer = null;
-var globalMiddleware = null;
-function init(config) {
-  configureLogging();
-  const finalConfig = createConfig(config);
-  logger2.info("Initializing Prefactor SDK", { transport: finalConfig.transportType });
-  if (globalMiddleware !== null) {
-    return globalMiddleware;
-  }
-  let transport;
-  if (finalConfig.transportType === "stdio") {
-    transport = new StdioTransport;
-  } else {
-    if (!finalConfig.httpConfig) {
-      throw new Error("HTTP transport requires httpConfig to be provided in configuration");
-    }
-    const httpConfig = HttpTransportConfigSchema.parse(finalConfig.httpConfig);
-    transport = new HttpTransport(httpConfig);
-  }
-  let partition;
-  if (finalConfig.httpConfig?.agentId) {
-    try {
-      partition = import_pfid2.extractPartition(finalConfig.httpConfig.agentId);
-      logger2.debug("Extracted partition from agent_id", { partition });
-    } catch (error) {
-      logger2.warn("Failed to extract partition from agent_id, using random partition", { error });
-    }
-  }
-  globalTracer = new Tracer(transport, partition);
-  const prefactorMiddleware = new PrefactorMiddleware(globalTracer);
-  const middleware = createMiddleware({
-    name: "prefactor",
-    wrapModelCall: async (request, handler) => {
-      return prefactorMiddleware.wrapModelCall(request, handler);
-    },
-    wrapToolCall: async (request, handler) => {
-      return prefactorMiddleware.wrapToolCall(request, handler);
-    },
-    beforeAgent: async (state) => {
-      await prefactorMiddleware.beforeAgent(state);
-    },
-    afterAgent: async (state) => {
-      await prefactorMiddleware.afterAgent(state);
-    }
-  });
-  globalMiddleware = middleware;
-  return middleware;
-}
-function getTracer() {
-  if (!globalTracer) {
-    init();
-  }
-  return globalTracer;
-}
-async function shutdown() {
-  if (globalTracer) {
-    logger2.info("Shutting down Prefactor SDK");
-    await globalTracer.close();
-  }
-  globalTracer = null;
-  globalMiddleware = null;
-}
-process.on("beforeExit", () => {
-  shutdown().catch((error) => {
-    console.error("Error during Prefactor SDK shutdown:", error);
-  });
-});
-export {
-  shutdown,
-  init,
-  getTracer,
-  Tracer,
-  SpanType,
-  SpanStatus,
-  PrefactorMiddleware
-};
-
-//# debugId=1DD2DA9AA541304F64756E2164756E21
+//# debugId=51D31C5E4283DDA964756E2164756E21