@prefactor/core 0.1.1 → 0.2.1

package/dist/index.cjs

@@ -32,58 +32,110 @@ __export(exports_src, {
   truncateString: () => truncateString,
   serializeValue: () => serializeValue,
   getLogger: () => getLogger,
+  createCore: () => createCore,
   createConfig: () => createConfig,
   configureLogging: () => configureLogging,
   Tracer: () => Tracer,
-  StdioTransport: () => StdioTransport,
   SpanType: () => SpanType,
   SpanStatus: () => SpanStatus,
   SpanContext: () => SpanContext,
   PartialHttpConfigSchema: () => PartialHttpConfigSchema,
   HttpTransportConfigSchema: () => HttpTransportConfigSchema,
   HttpTransport: () => HttpTransport,
-  ConfigSchema: () => ConfigSchema
+  ConfigSchema: () => ConfigSchema,
+  AgentInstanceManager: () => AgentInstanceManager
 });
 module.exports = __toCommonJS(exports_src);
 
+// packages/core/src/agent/instance-manager.ts
+class AgentInstanceManager {
+  transport;
+  options;
+  registeredSchema = null;
+  constructor(transport, options) {
+    this.transport = transport;
+    this.options = options;
+  }
+  registerSchema(schema) {
+    if (this.registeredSchema === null) {
+      this.registeredSchema = schema;
+      this.transport.registerSchema(schema);
+      return;
+    }
+    const existingSchema = stableStringify(this.registeredSchema);
+    const incomingSchema = stableStringify(schema);
+    if (existingSchema !== incomingSchema) {
+      console.warn("A different schema was provided after registration; ignoring subsequent schema.");
+    }
+  }
+  startInstance(options = {}) {
+    if (!this.options.allowUnregisteredSchema && this.registeredSchema === null) {
+      console.warn("Schema must be registered before starting an agent instance.");
+      return;
+    }
+    this.transport.startAgentInstance(options);
+  }
+  finishInstance() {
+    this.transport.finishAgentInstance();
+  }
+}
+function stableStringify(value) {
+  return JSON.stringify(normalizeValue(value));
+}
+function normalizeValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeValue(entry));
+  }
+  if (value && typeof value === "object") {
+    const normalized = {};
+    const objectValue = value;
+    const keys = Object.keys(objectValue).sort((a, b) => a.localeCompare(b));
+    for (const key of keys) {
+      normalized[key] = normalizeValue(objectValue[key]);
+    }
+    return normalized;
+  }
+  return value;
+}
 // packages/core/src/config.ts
 var import_zod = require("zod");
+var DEFAULT_RETRY_ON_STATUS_CODES = [
+  429,
+  ...Array.from({ length: 100 }, (_, index) => 500 + index)
+];
+var HttpStatusCodeSchema = import_zod.z.number().int().min(100).max(599);
 var HttpTransportConfigSchema = import_zod.z.object({
   apiUrl: import_zod.z.string().url(),
   apiToken: import_zod.z.string().min(1),
   agentId: import_zod.z.string().optional(),
-  agentVersion: import_zod.z.string().optional(),
+  agentIdentifier: import_zod.z.string().default("v1.0.0"),
   agentName: import_zod.z.string().optional(),
   agentDescription: import_zod.z.string().optional(),
   agentSchema: import_zod.z.record(import_zod.z.unknown()).optional(),
-  agentSchemaVersion: import_zod.z.string().optional(),
-  skipSchema: import_zod.z.boolean().default(false),
   requestTimeout: import_zod.z.number().positive().default(30000),
-  connectTimeout: import_zod.z.number().positive().default(1e4),
   maxRetries: import_zod.z.number().int().nonnegative().default(3),
   initialRetryDelay: import_zod.z.number().positive().default(1000),
   maxRetryDelay: import_zod.z.number().positive().default(60000),
-  retryMultiplier: import_zod.z.number().positive().default(2)
+  retryMultiplier: import_zod.z.number().positive().default(2),
+  retryOnStatusCodes: import_zod.z.array(HttpStatusCodeSchema).default([...DEFAULT_RETRY_ON_STATUS_CODES])
 });
 var PartialHttpConfigSchema = import_zod.z.object({
   apiUrl: import_zod.z.string().url(),
   apiToken: import_zod.z.string().min(1),
   agentId: import_zod.z.string().optional(),
-  agentVersion: import_zod.z.string().optional(),
+  agentIdentifier: import_zod.z.string().optional(),
   agentName: import_zod.z.string().optional(),
   agentDescription: import_zod.z.string().optional(),
   agentSchema: import_zod.z.record(import_zod.z.unknown()).optional(),
-  agentSchemaVersion: import_zod.z.string().optional(),
-  skipSchema: import_zod.z.boolean().optional(),
   requestTimeout: import_zod.z.number().positive().optional(),
-  connectTimeout: import_zod.z.number().positive().optional(),
   maxRetries: import_zod.z.number().int().nonnegative().optional(),
   initialRetryDelay: import_zod.z.number().positive().optional(),
   maxRetryDelay: import_zod.z.number().positive().optional(),
-  retryMultiplier: import_zod.z.number().positive().optional()
+  retryMultiplier: import_zod.z.number().positive().optional(),
+  retryOnStatusCodes: import_zod.z.array(HttpStatusCodeSchema).optional()
 });
 var ConfigSchema = import_zod.z.object({
-  transportType: import_zod.z.enum(["stdio", "http"]).default("stdio"),
+  transportType: import_zod.z.enum(["http"]).default("http"),
   sampleRate: import_zod.z.number().min(0).max(1).default(1),
   captureInputs: import_zod.z.boolean().default(true),
   captureOutputs: import_zod.z.boolean().default(true),
@@ -92,52 +144,93 @@ var ConfigSchema = import_zod.z.object({
   httpConfig: PartialHttpConfigSchema.optional()
 });
 function createConfig(options) {
+  const retryOnStatusCodesFromEnv = parseRetryOnStatusCodesEnv(process.env.PREFACTOR_RETRY_ON_STATUS_CODES);
   const config = {
-    transportType: options?.transportType ?? process.env.PREFACTOR_TRANSPORT ?? "stdio",
+    transportType: options?.transportType ?? process.env.PREFACTOR_TRANSPORT ?? "http",
     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
+    httpConfig: options?.httpConfig ? {
+      ...options.httpConfig,
+      retryOnStatusCodes: options.httpConfig.retryOnStatusCodes ?? retryOnStatusCodesFromEnv
+    } : undefined
   };
   return ConfigSchema.parse(config);
 }
+function parseRetryOnStatusCodesEnv(value) {
+  if (!value) {
+    return;
+  }
+  const parsedCodes = value.split(",").map((status) => status.trim()).filter((status) => /^\d{3}$/.test(status)).map((status) => Number(status)).filter((status) => status >= 100 && status <= 599);
+  return parsedCodes.length > 0 ? parsedCodes : undefined;
+}
+// packages/core/src/create-core.ts
+var import_pfid2 = require("@prefactor/pfid");
+
+// packages/core/src/tracing/tracer.ts
+var import_pfid = require("@prefactor/pfid");
+
 // packages/core/src/tracing/context.ts
 var import_node_async_hooks = require("node:async_hooks");
 var spanStorage = new import_node_async_hooks.AsyncLocalStorage;
 
 class SpanContext {
   static getCurrent() {
-    return spanStorage.getStore();
+    const stack = spanStorage.getStore() ?? [];
+    return stack[stack.length - 1];
+  }
+  static getStack() {
+    return [...spanStorage.getStore() ?? []];
+  }
+  static enter(span) {
+    const stack = [...spanStorage.getStore() ?? [], span];
+    spanStorage.enterWith(stack);
+  }
+  static exit() {
+    const stack = [...spanStorage.getStore() ?? []];
+    stack.pop();
+    spanStorage.enterWith(stack);
   }
   static run(span, fn) {
-    return spanStorage.run(span, fn);
+    const stack = spanStorage.getStore() ?? [];
+    const resource = new import_node_async_hooks.AsyncResource("SpanContext.run");
+    try {
+      return resource.runInAsyncScope(() => spanStorage.run([...stack, span], fn));
+    } finally {
+      resource.emitDestroy();
+    }
   }
   static async runAsync(span, fn) {
-    return spanStorage.run(span, fn);
+    const stack = spanStorage.getStore() ?? [];
+    const resource = new import_node_async_hooks.AsyncResource("SpanContext.runAsync");
+    try {
+      return await resource.runInAsyncScope(() => spanStorage.run([...stack, span], fn));
+    } finally {
+      resource.emitDestroy();
+    }
   }
   static clear() {
     spanStorage.disable();
   }
 }
+
 // packages/core/src/tracing/span.ts
-var SpanType;
-((SpanType2) => {
-  SpanType2["AGENT"] = "agent";
-  SpanType2["LLM"] = "llm";
-  SpanType2["TOOL"] = "tool";
-  SpanType2["CHAIN"] = "chain";
-  SpanType2["RETRIEVER"] = "retriever";
-})(SpanType ||= {});
+var SpanType = {
+  AGENT: "agent",
+  LLM: "llm",
+  TOOL: "tool",
+  CHAIN: "chain"
+};
 var SpanStatus;
 ((SpanStatus2) => {
   SpanStatus2["RUNNING"] = "running";
   SpanStatus2["SUCCESS"] = "success";
   SpanStatus2["ERROR"] = "error";
 })(SpanStatus ||= {});
+
 // packages/core/src/tracing/tracer.ts
-var import_pfid = require("@prefactor/pfid");
 class Tracer {
   transport;
   partition;
@@ -146,11 +239,12 @@ class Tracer {
     this.partition = partition ?? import_pfid.generatePartition();
   }
   startSpan(options) {
+    const parentSpan = SpanContext.getCurrent();
     const spanId = import_pfid.generate(this.partition);
-    const traceId = options.traceId ?? import_pfid.generate(this.partition);
+    const traceId = parentSpan?.traceId ?? import_pfid.generate(this.partition);
     const span = {
       spanId,
-      parentSpanId: options.parentSpanId ?? null,
+      parentSpanId: parentSpan?.spanId ?? null,
       traceId,
       name: options.name,
       spanType: options.spanType,
@@ -161,10 +255,9 @@ class Tracer {
       outputs: null,
       tokenUsage: null,
       error: null,
-      metadata: options.metadata ?? {},
-      tags: options.tags ?? []
+      metadata: options.metadata ?? {}
     };
-    if (options.spanType === "agent") {
+    if (options.spanType === SpanType.AGENT) {
       try {
         this.transport.emit(span);
       } catch (error) {
@@ -174,7 +267,8 @@ class Tracer {
     return span;
   }
   endSpan(span, options) {
-    span.endTime = Date.now();
+    const endTime = Date.now();
+    span.endTime = endTime;
     span.outputs = options?.outputs ?? null;
     span.tokenUsage = options?.tokenUsage ?? null;
     if (options?.error) {
@@ -188,13 +282,20 @@ class Tracer {
       span.status = "success" /* SUCCESS */;
     }
     try {
-      if (span.spanType === "agent") {
-        this.transport.finishSpan(span.spanId, span.endTime);
+      if (span.spanType === SpanType.AGENT) {
+        this.transport.finishSpan(span.spanId, endTime);
       } else {
         this.transport.emit(span);
       }
     } catch (error) {
-      console.error("Failed to emit/finish span:", error);
+      console.error("Failed to emit span action:", error);
+    }
+  }
+  async close() {
+    try {
+      await this.transport.close();
+    } catch (error) {
+      console.error("Failed to close transport:", error);
     }
   }
   startAgentInstance() {
@@ -211,18 +312,150 @@ class Tracer {
       console.error("Failed to finish agent instance:", error);
     }
   }
-  async close() {
+}
+
+// packages/core/src/queue/in-memory-queue.ts
+class InMemoryQueue {
+  items = [];
+  waiters = [];
+  isClosed = false;
+  async put(item) {
+    if (this.isClosed) {
+      throw new Error("Cannot put item into a closed queue");
+    }
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter({ done: false, item });
+      return;
+    }
+    this.items.push({ item });
+  }
+  async get() {
+    if (this.items.length > 0) {
+      const entry = this.items.shift();
+      if (entry) {
+        return { done: false, item: entry.item };
+      }
+    }
+    if (this.isClosed) {
+      return { done: true };
+    }
+    return new Promise((resolve) => {
+      this.waiters.push(resolve);
+    });
+  }
+  close() {
+    if (this.isClosed) {
+      return;
+    }
+    this.isClosed = true;
+    while (this.waiters.length > 0) {
+      const waiter = this.waiters.shift();
+      if (waiter) {
+        waiter({ done: true });
+      }
+    }
+  }
+  size() {
+    return this.items.length;
+  }
+}
+
+// packages/core/src/queue/task-executor.ts
+var DEFAULT_WORKER_COUNT = 1;
+var DEFAULT_MAX_RETRIES = 0;
+var DEFAULT_RETRY_DELAY_MS = 0;
+
+class TaskExecutor {
+  queue;
+  handler;
+  isRunning = false;
+  workerPromises = [];
+  workerCount;
+  maxRetries;
+  retryDelayMs;
+  onError;
+  constructor(queue, handler, options = {}) {
+    this.queue = queue;
+    this.handler = handler;
+    this.workerCount = Math.max(options.workerCount ?? DEFAULT_WORKER_COUNT, 1);
+    this.maxRetries = Math.max(options.maxRetries ?? DEFAULT_MAX_RETRIES, 0);
+    this.retryDelayMs = Math.max(options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS, 0);
+    this.onError = options.onError;
+  }
+  start() {
+    if (this.isRunning) {
+      return;
+    }
+    this.isRunning = true;
+    this.workerPromises = Array.from({ length: this.workerCount }, () => this.runWorker());
+  }
+  async stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.isRunning = false;
+    this.queue.close();
+    await Promise.all(this.workerPromises);
+    this.workerPromises = [];
+  }
+  async runWorker() {
+    while (true) {
+      const result = await this.queue.get();
+      if (result.done) {
+        return;
+      }
+      await this.executeWithRetry(result.item);
+    }
+  }
+  async executeWithRetry(item) {
+    let attempt = 0;
+    while (attempt <= this.maxRetries) {
+      try {
+        await this.handler(item);
+        return;
+      } catch (error) {
+        if (attempt >= this.maxRetries) {
+          await this.safeOnError(error, item);
+          return;
+        }
+        if (this.retryDelayMs > 0) {
+          await new Promise((resolve) => setTimeout(resolve, this.retryDelayMs));
+        }
+      }
+      attempt += 1;
+    }
+  }
+  async safeOnError(error, item) {
+    if (!this.onError) {
+      return;
+    }
     try {
-      await this.transport.close();
-    } catch (error) {
-      console.error("Failed to close transport:", error);
+      await this.onError(error, item);
+    } catch {
+      return;
     }
   }
 }
+
 // packages/core/src/utils/logging.ts
+var LogLevel;
+((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+})(LogLevel ||= {});
+
 class Logger {
   namespace;
-  static level = 1 /* INFO */;
+  static level = (() => {
+    const level = process.env.PREFACTOR_LOG_LEVEL?.toUpperCase();
+    if (level && level in LogLevel) {
+      return LogLevel[level];
+    }
+    return 1 /* INFO */;
+  })();
   constructor(namespace) {
     this.namespace = namespace;
   }
@@ -266,128 +499,358 @@ function configureLogging() {
   }
 }
 
+// packages/core/src/transport/http/agent-instance-client.ts
+class AgentInstanceClient {
+  httpClient;
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  register(payload) {
+    return this.httpClient.request("/api/v1/agent_instance/register", {
+      method: "POST",
+      body: payload
+    });
+  }
+  async start(agentInstanceId) {
+    await this.httpClient.request(`/api/v1/agent_instance/${agentInstanceId}/start`, {
+      method: "POST",
+      body: {}
+    });
+  }
+  async finish(agentInstanceId) {
+    await this.httpClient.request(`/api/v1/agent_instance/${agentInstanceId}/finish`, {
+      method: "POST",
+      body: {}
+    });
+  }
+}
+
+// packages/core/src/transport/http/retry-policy.ts
+var JITTER_MIN = 0.5;
+function shouldRetryStatusCode(statusCode, retryOnStatusCodes) {
+  return retryOnStatusCodes.includes(statusCode);
+}
+function calculateRetryDelay(attempt, config, random = Math.random) {
+  const baseDelay = Math.min(config.initialRetryDelay * config.retryMultiplier ** attempt, config.maxRetryDelay);
+  const jitterMultiplier = JITTER_MIN + random() * JITTER_MIN;
+  return Math.round(baseDelay * jitterMultiplier);
+}
+
+// packages/core/src/transport/http/http-client.ts
+class HttpClientError extends Error {
+  url;
+  method;
+  status;
+  statusText;
+  responseBody;
+  retryable;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.name = "HttpClientError";
+    this.url = options.url;
+    this.method = options.method;
+    this.status = options.status;
+    this.statusText = options.statusText;
+    this.responseBody = options.responseBody;
+    this.retryable = options.retryable;
+  }
+}
+
+class HttpClient {
+  config;
+  fetchFn;
+  sleep;
+  random;
+  constructor(config, dependencies = {}) {
+    this.config = config;
+    this.fetchFn = dependencies.fetchFn ?? fetch;
+    this.sleep = dependencies.sleep ?? ((delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)));
+    this.random = dependencies.random ?? Math.random;
+  }
+  async request(path, options = {}) {
+    const url = new URL(path, this.config.apiUrl).toString();
+    const method = options.method ?? "GET";
+    let attempt = 0;
+    while (true) {
+      const headers = new Headers(options.headers);
+      headers.set("Authorization", `Bearer ${this.config.apiToken}`);
+      if (options.body !== undefined && !headers.has("Content-Type")) {
+        headers.set("Content-Type", "application/json");
+      }
+      const requestInit = {
+        ...options,
+        method,
+        headers,
+        body: options.body === undefined ? undefined : JSON.stringify(options.body),
+        signal: AbortSignal.timeout(options.timeoutMs ?? this.config.requestTimeout)
+      };
+      try {
+        const response = await this.fetchFn(url, requestInit);
+        if (response.ok) {
+          return await parseResponseBody(response);
+        }
+        const responseBody = await parseResponseBody(response);
+        const canRetry = attempt < this.config.maxRetries && shouldRetryStatusCode(response.status, this.config.retryOnStatusCodes);
+        if (canRetry) {
+          const delayMs = calculateRetryDelay(attempt, this.config, this.random);
+          await this.sleep(delayMs);
+          attempt += 1;
+          continue;
+        }
+        throw new HttpClientError(`HTTP request failed with status ${response.status}`, {
+          url,
+          method,
+          status: response.status,
+          statusText: response.statusText,
+          responseBody,
+          retryable: shouldRetryStatusCode(response.status, this.config.retryOnStatusCodes)
+        });
+      } catch (error) {
+        if (error instanceof HttpClientError) {
+          throw error;
+        }
+        const canRetry = attempt < this.config.maxRetries && isRetryableNetworkError(error);
+        if (canRetry) {
+          const delayMs = calculateRetryDelay(attempt, this.config, this.random);
+          await this.sleep(delayMs);
+          attempt += 1;
+          continue;
+        }
+        throw new HttpClientError("HTTP request failed due to network error", {
+          url,
+          method,
+          retryable: false,
+          cause: error
+        });
+      }
+    }
+  }
+}
+function isRetryableNetworkError(error) {
+  if (error instanceof TypeError) {
+    return true;
+  }
+  if (error instanceof DOMException && (error.name === "AbortError" || error.name === "TimeoutError")) {
+    return true;
+  }
+  if (error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError")) {
+    return true;
+  }
+  return false;
+}
+async function parseResponseBody(response) {
+  const bodyText = await response.text();
+  if (!bodyText) {
+    return null;
+  }
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    try {
+      return JSON.parse(bodyText);
+    } catch {
+      return bodyText;
+    }
+  }
+  try {
+    return JSON.parse(bodyText);
+  } catch {
+    return bodyText;
+  }
+}
+
+// packages/core/src/transport/http/agent-span-client.ts
+class AgentSpanClient {
+  httpClient;
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  create(payload) {
+    return this.httpClient.request("/api/v1/agent_spans", {
+      method: "POST",
+      body: payload
+    });
+  }
+  async finish(spanId, timestamp) {
+    try {
+      await this.httpClient.request(`/api/v1/agent_spans/${spanId}/finish`, {
+        method: "POST",
+        body: { timestamp }
+      });
+    } catch (error) {
+      if (error instanceof HttpClientError && error.status === 409 && isAlreadyFinishedError(error.responseBody)) {
+        return;
+      }
+      throw error;
+    }
+  }
+}
+function isAlreadyFinishedError(responseBody) {
+  if (!responseBody || typeof responseBody !== "object") {
+    return false;
+  }
+  const payload = responseBody;
+  return payload.code === "invalid_action";
+}
+
 // packages/core/src/transport/http.ts
 var logger = getLogger("http-transport");
 
 class HttpTransport {
   config;
-  queue = [];
-  processing = false;
   closed = false;
+  actionQueue = new InMemoryQueue;
+  taskExecutor;
+  agentInstanceClient;
+  agentSpanClient;
+  previousAgentSchema = null;
+  requiresNewAgentIdentifier = false;
+  previousAgentIdentifier = null;
   agentInstanceId = null;
   spanIdMap = new Map;
+  pendingFinishes = new Map;
   constructor(config) {
     this.config = config;
-    this.startProcessing();
+    const httpClient = new HttpClient(config);
+    this.agentInstanceClient = new AgentInstanceClient(httpClient);
+    this.agentSpanClient = new AgentSpanClient(httpClient);
+    this.taskExecutor = new TaskExecutor(this.actionQueue, this.processAction, {
+      workerCount: 1,
+      onError: async (error) => {
+        logger.error("Error processing HTTP action:", error);
+      }
+    });
+    this.taskExecutor.start();
+  }
+  registerSchema(schema) {
+    this.enqueue({ type: "schema_register", schema });
+  }
+  startAgentInstance(options) {
+    this.enqueue({ type: "agent_start", options });
+  }
+  finishAgentInstance() {
+    this.enqueue({ type: "agent_finish" });
   }
   emit(span) {
-    if (this.closed) {
-      return;
-    }
-    this.queue.push({ type: "span", data: span });
+    this.enqueue({ type: "span_end", span });
   }
   finishSpan(spanId, endTime) {
-    if (this.closed) {
-      return;
-    }
-    const timestamp = new Date(endTime).toISOString();
-    this.queue.push({ type: "finish_span", data: { spanId, timestamp } });
+    this.enqueue({ type: "span_finish", spanId, endTime });
   }
-  startAgentInstance() {
-    if (this.closed) {
-      return;
+  async close() {
+    this.closed = true;
+    await this.taskExecutor.stop();
+    if (this.pendingFinishes.size > 0) {
+      logger.warn(`Transport closed with ${this.pendingFinishes.size} pending span finish(es) that could not be processed`);
+      this.pendingFinishes.clear();
     }
-    this.queue.push({ type: "start_agent", data: null });
   }
-  finishAgentInstance() {
+  enqueue(action) {
     if (this.closed) {
       return;
     }
-    this.queue.push({ type: "finish_agent", data: null });
+    this.actionQueue.put(action).catch((error) => {
+      logger.error("Failed to enqueue HTTP action:", error);
+    });
   }
-  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;
+  processAction = async (action) => {
+    switch (action.type) {
+      case "schema_register": {
+        const incomingSchema = JSON.stringify(action.schema);
+        if (this.previousAgentSchema !== null && this.previousAgentSchema !== incomingSchema) {
+          this.requiresNewAgentIdentifier = true;
+          this.previousAgentIdentifier = this.config.agentIdentifier;
+          this.agentInstanceId = null;
+        }
+        this.previousAgentSchema = incomingSchema;
+        this.config.agentSchema = action.schema;
+        return;
       }
-      const item = this.queue.shift();
-      if (!item)
-        continue;
-      try {
-        if (!this.agentInstanceId && item.type !== "start_agent") {
+      case "agent_start": {
+        if (this.requiresNewAgentIdentifier) {
+          const nextAgentIdentifier = action.options?.agentIdentifier;
+          if (nextAgentIdentifier === undefined || nextAgentIdentifier === this.previousAgentIdentifier) {
+            logger.error("Schema changed; starting an agent requires a new agentIdentifier value.");
+            return;
+          }
+          this.requiresNewAgentIdentifier = false;
+          this.previousAgentIdentifier = null;
+        }
+        if (action.options?.agentId !== undefined)
+          this.config.agentId = action.options.agentId;
+        if (action.options?.agentIdentifier !== undefined) {
+          this.config.agentIdentifier = action.options.agentIdentifier;
+        }
+        if (action.options?.agentName !== undefined)
+          this.config.agentName = action.options.agentName;
+        if (action.options?.agentDescription !== undefined) {
+          this.config.agentDescription = action.options.agentDescription;
+        }
+        await this.startAgentInstanceHttp();
+        return;
+      }
+      case "agent_finish":
+        await this.finishAgentInstanceHttp();
+        return;
+      case "span_end":
+        if (!this.agentInstanceId) {
           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;
+        await this.sendSpan(action.span);
+        return;
+      case "span_finish": {
+        const backendSpanId = this.spanIdMap.get(action.spanId);
+        if (backendSpanId) {
+          const timestamp = new Date(action.endTime).toISOString();
+          await this.finishSpanHttp({ spanId: action.spanId, timestamp });
+        } else {
+          this.pendingFinishes.set(action.spanId, action.endTime);
         }
-      } catch (error) {
-        logger.error("Error processing queue item:", error);
+        return;
       }
     }
-    this.processing = false;
+  };
+  async processPendingFinishes(spanId) {
+    if (!this.pendingFinishes.has(spanId)) {
+      return;
+    }
+    const pendingEndTime = this.pendingFinishes.get(spanId);
+    if (pendingEndTime === undefined) {
+      return;
+    }
+    try {
+      const timestamp = new Date(pendingEndTime).toISOString();
+      await this.finishSpanHttp({ spanId, timestamp });
+      this.pendingFinishes.delete(spanId);
+    } catch (error) {
+      logger.error("Error processing pending span finish:", error);
+    }
   }
-  async sendSpan(span, retry = 0) {
-    const url = `${this.config.apiUrl}/api/v1/agent_spans`;
+  async sendSpan(span) {
     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);
-        }
+      const response = await this.agentSpanClient.create(payload);
+      const backendSpanId = response.details?.id;
+      if (!backendSpanId) {
         return;
       }
-      if ((response.status >= 500 || response.status === 429) && retry < this.config.maxRetries) {
-        const delay = Math.min(this.config.initialRetryDelay * 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}`);
+      this.spanIdMap.set(span.spanId, backendSpanId);
+      await this.processPendingFinishes(span.spanId);
     } catch (error) {
       logger.error("Error sending span:", error);
-      if (retry < this.config.maxRetries) {
-        const delay = Math.min(this.config.initialRetryDelay * 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 apiStatus = this.mapStatusForApi(span.status);
     const payload = {
       span_id: span.spanId,
       trace_id: span.traceId,
       name: span.name,
-      status: span.status,
+      status: apiStatus,
       inputs: span.inputs,
       outputs: span.outputs,
       metadata: span.metadata,
-      tags: span.tags,
       token_usage: null,
       error: null
     };
@@ -410,6 +873,7 @@ class HttpTransport {
       details: {
         agent_instance_id: this.agentInstanceId,
         schema_name: span.spanType,
+        status: apiStatus,
         payload,
         parent_span_id: parentSpanId,
         started_at: startedAt,
@@ -417,103 +881,51 @@ class HttpTransport {
       }
     };
   }
-  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" } }
-        }
-      }
-    };
+  mapStatusForApi(status) {
+    switch (status) {
+      case "running":
+        return "active";
+      case "success":
+        return "complete";
+      case "error":
+        return "failed";
+      default:
+        return "active";
+    }
   }
   async ensureAgentRegistered() {
     if (this.agentInstanceId) {
-      return;
+      return true;
     }
-    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) {
+    if (this.config.agentIdentifier) {
       payload.agent_version = {
-        external_identifier: this.config.agentVersion,
+        external_identifier: this.config.agentIdentifier,
         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");
+    if (this.config.agentSchema) {
       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}`);
-      }
+      const data = await this.agentInstanceClient.register(payload);
+      this.agentInstanceId = data.details?.id ?? null;
     } catch (error) {
       logger.error("Error registering agent:", error);
     }
+    return this.agentInstanceId !== null;
   }
   async startAgentInstanceHttp() {
-    await this.ensureAgentRegistered();
-    if (!this.agentInstanceId) {
+    const isRegistered = await this.ensureAgentRegistered();
+    if (!isRegistered || !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}`);
-      }
+      await this.agentInstanceClient.start(this.agentInstanceId);
     } catch (error) {
       logger.error("Error starting agent instance:", error);
     }
@@ -523,23 +935,12 @@ class HttpTransport {
       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}`);
-      }
+      await this.agentInstanceClient.finish(this.agentInstanceId);
     } catch (error) {
       logger.error("Error finishing agent instance:", error);
     }
+    this.agentInstanceId = null;
   }
   async finishSpanHttp(data) {
     const backendSpanId = this.spanIdMap.get(data.spanId);
@@ -547,35 +948,38 @@ class HttpTransport {
       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}`);
-      }
+      await this.agentSpanClient.finish(backendSpanId, data.timestamp);
     } 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");
-    }
-  }
+}
+
+// packages/core/src/create-core.ts
+function createCore(config) {
+  if (!config.httpConfig) {
+    throw new Error("HTTP transport requires httpConfig to be provided in configuration");
+  }
+  const httpConfig = HttpTransportConfigSchema.parse(config.httpConfig);
+  const transport = new HttpTransport(httpConfig);
+  let partition;
+  if (config.httpConfig.agentId) {
+    try {
+      partition = import_pfid2.extractPartition(config.httpConfig.agentId);
+    } catch {
+      partition = undefined;
+    }
+  }
+  const tracer = new Tracer(transport, partition);
+  const allowUnregisteredSchema = Boolean(config.httpConfig.agentSchema);
+  const agentManager = new AgentInstanceManager(transport, {
+    allowUnregisteredSchema
+  });
+  const shutdown = async () => {
+    await tracer.close();
+  };
+  return { tracer, agentManager, shutdown };
 }
 // packages/core/src/utils/serialization.ts
 function truncateString(value, maxLength) {
@@ -611,32 +1015,4 @@ function serializeValue(value, maxLength = 1e4) {
   }
 }
 
-// packages/core/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;
-  }
-}
-
-//# debugId=E95D2EBB45D9CCA264756E2164756E21
+//# debugId=97A3CED64412936764756E2164756E21