@prefactor/core 0.3.1 → 0.3.3

package/dist/index.js

@@ -561,6 +561,32 @@ function calculateRetryDelay(attempt, config, random = Math.random) {
   return Math.round(baseDelay * jitterMultiplier);
 }
 
+// packages/core/src/version.ts
+var PACKAGE_NAME = "@prefactor/core";
+var PACKAGE_VERSION = "0.3.3";
+
+// packages/core/src/transport/http/sdk-request-header.ts
+var DEFAULT_SDK_REQUEST_HEADER = formatSdkHeaderEntry(PACKAGE_NAME, PACKAGE_VERSION);
+function buildSdkRequestHeader(...entries) {
+  const parts = [
+    ...entries.filter((entry) => Boolean(entry)).map((entry) => normalizeSdkHeaderEntry(entry)),
+    DEFAULT_SDK_REQUEST_HEADER
+  ];
+  return Array.from(new Set(parts)).join(" ");
+}
+function normalizeSdkHeaderEntry(entry) {
+  const atIndex = entry.lastIndexOf("@");
+  if (atIndex <= 0) {
+    return entry;
+  }
+  const packageName = entry.slice(0, atIndex);
+  const version = entry.slice(atIndex + 1);
+  return version ? `${packageName}@${version}` : packageName;
+}
+function formatSdkHeaderEntry(packageName, version) {
+  return `${packageName}@${version}`;
+}
+
 // packages/core/src/transport/http/http-client.ts
 class HttpClientError extends Error {
   url;
@@ -586,11 +612,13 @@ class HttpClient {
   fetchFn;
   sleep;
   random;
-  constructor(config, dependencies = {}) {
+  sdkHeader;
+  constructor(config, dependencies = {}, sdkHeaderEntry) {
     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;
+    this.sdkHeader = sdkHeaderEntry ? buildSdkRequestHeader(sdkHeaderEntry) : DEFAULT_SDK_REQUEST_HEADER;
   }
   async request(path, options = {}) {
     const url = new URL(path, this.config.apiUrl).toString();
@@ -599,6 +627,7 @@ class HttpClient {
     while (true) {
       const headers = new Headers(options.headers);
       headers.set("Authorization", `Bearer ${this.config.apiToken}`);
+      headers.set("X-Prefactor-SDK", this.sdkHeader);
       if (options.body !== undefined && !headers.has("Content-Type")) {
         headers.set("Content-Type", "application/json");
       }
@@ -738,9 +767,9 @@ class HttpTransport {
   spanIdMap = new Map;
   pendingFinishes = new Map;
   pendingChildren = new Map;
-  constructor(config) {
+  constructor(config, sdkHeaderEntry) {
     this.config = config;
-    const httpClient = new HttpClient(config);
+    const httpClient = sdkHeaderEntry === undefined ? new HttpClient(config) : new HttpClient(config, {}, sdkHeaderEntry);
     this.agentInstanceClient = new AgentInstanceClient(httpClient);
     this.agentSpanClient = new AgentSpanClient(httpClient);
     this.taskExecutor = new TaskExecutor(this.actionQueue, this.processAction, {
@@ -1026,12 +1055,12 @@ class HttpTransport {
 }
 
 // packages/core/src/create-core.ts
-function createCore(config) {
+function createCore(config, options = {}) {
   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);
+  const transport = options.sdkHeaderEntry === undefined ? new HttpTransport(httpConfig) : new HttpTransport(httpConfig, options.sdkHeaderEntry);
   let partition;
   if (config.httpConfig.agentId) {
     try {
@@ -1143,7 +1172,8 @@ class PrefactorClient {
   }
 }
 function init(options) {
-  const nextInitKey = buildInitKey(options);
+  const sdkHeaderEntry = options.provider.getSdkHeaderEntry?.();
+  const nextInitKey = buildInitKey(options, sdkHeaderEntry);
   if (prefactorClient) {
     if (prefactorInitKey !== nextInitKey) {
       throw new Error("Prefactor is already initialized with a different provider or configuration. " + "Call shutdown() before re-initializing with different options.");
@@ -1163,7 +1193,21 @@ function init(options) {
       }
     };
   }
-  const core = createCore(finalConfig);
+  if (finalConfig.httpConfig?.agentSchema) {
+    const normalizedSchema = options.provider.normalizeAgentSchema?.(finalConfig.httpConfig.agentSchema);
+    if (normalizedSchema) {
+      finalConfig = {
+        ...finalConfig,
+        httpConfig: {
+          ...finalConfig.httpConfig,
+          agentSchema: normalizedSchema
+        }
+      };
+    }
+  }
+  const core = createCore(finalConfig, {
+    sdkHeaderEntry
+  });
   const httpConfig = finalConfig.httpConfig;
   if (httpConfig?.agentSchema) {
     core.agentManager.registerSchema(httpConfig.agentSchema);
@@ -1176,9 +1220,13 @@ function init(options) {
 function getClient() {
   return prefactorClient;
 }
-function buildInitKey(options) {
+function buildInitKey(options, sdkHeaderEntry) {
   const providerType = options.provider.constructor?.name ?? "anonymous-provider";
-  return `${providerType}:${stableStringify2(options.httpConfig ?? null)}`;
+  return stableStringify2({
+    providerType,
+    httpConfig: options.httpConfig ?? null,
+    sdkHeaderEntry: sdkHeaderEntry ?? null
+  });
 }
 function stableStringify2(value) {
   return JSON.stringify(normalizeValue2(value));
@@ -1198,6 +1246,160 @@ function normalizeValue2(value) {
   }
   return value;
 }
+// packages/core/src/tool-schema.ts
+var logger2 = getLogger("tool-schema");
+function normalizeAgentToolSchemas(agentSchema, {
+  defaultAgentSchema,
+  providerName
+}) {
+  const toolSchemas = extractToolSchemas(agentSchema, providerName);
+  return {
+    agentSchema: mergeWithDefaultAgentSchema(stripToolSchemas(agentSchema), defaultAgentSchema),
+    toolSchemas,
+    toolSpanTypes: buildToolSpanTypes(toolSchemas)
+  };
+}
+function resolveMappedSpanType(toolName, toolSpanTypes, defaultSpanType) {
+  return toolSpanTypes?.[toolName] ?? defaultSpanType;
+}
+function extractToolSchemas(agentSchema, providerName) {
+  const rawToolSchemas = getRawToolSchemas(agentSchema);
+  if (!rawToolSchemas) {
+    return;
+  }
+  const toolSchemas = {};
+  const toolBySpanType = new Map;
+  for (const [toolName, rawConfig] of Object.entries(rawToolSchemas)) {
+    const parsedToolSchema = parseToolSchemaConfig(toolName, rawConfig, providerName, toolBySpanType);
+    if (!parsedToolSchema) {
+      continue;
+    }
+    toolSchemas[toolName] = parsedToolSchema;
+  }
+  return Object.keys(toolSchemas).length > 0 ? toolSchemas : undefined;
+}
+function getRawToolSchemas(agentSchema) {
+  if (!agentSchema || typeof agentSchema !== "object" || Array.isArray(agentSchema)) {
+    return;
+  }
+  const rawToolSchemas = agentSchema.toolSchemas;
+  if (rawToolSchemas === undefined) {
+    return;
+  }
+  if (!rawToolSchemas || typeof rawToolSchemas !== "object" || Array.isArray(rawToolSchemas)) {
+    logger2.warn("Ignoring invalid agentSchema.toolSchemas: expected an object keyed by tool name.");
+    return;
+  }
+  return rawToolSchemas;
+}
+function parseToolSchemaConfig(toolName, rawConfig, providerName, toolBySpanType) {
+  if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) {
+    logger2.warn(`Invalid agentSchema.toolSchemas.${toolName}: expected an object with spanType and inputSchema.`);
+    return;
+  }
+  const config = rawConfig;
+  if (typeof config.spanType !== "string") {
+    logger2.warn(`Invalid agentSchema.toolSchemas.${toolName}.spanType: expected a non-empty string.`);
+    return;
+  }
+  const inputSchema = assertValidInputSchema(toolName, config.inputSchema);
+  if (!inputSchema) {
+    return;
+  }
+  const normalizedSpanType = normalizeUniqueToolSpanType(toolName, config.spanType, providerName, toolBySpanType);
+  if (!normalizedSpanType) {
+    return;
+  }
+  return {
+    spanType: normalizedSpanType,
+    inputSchema
+  };
+}
+function assertValidInputSchema(toolName, inputSchema) {
+  if (!inputSchema || typeof inputSchema !== "object" || Array.isArray(inputSchema)) {
+    logger2.warn(`Invalid agentSchema.toolSchemas.${toolName}.inputSchema: expected an object.`);
+    return;
+  }
+  return inputSchema;
+}
+function normalizeUniqueToolSpanType(toolName, spanType, providerName, toolBySpanType) {
+  const normalizedSpanType = normalizeToolSpanType(spanType, toolName, providerName);
+  if (!normalizedSpanType) {
+    return;
+  }
+  const conflictingTool = toolBySpanType.get(normalizedSpanType);
+  if (conflictingTool && conflictingTool !== toolName) {
+    logger2.warn(`Invalid agentSchema.toolSchemas.${toolName}.spanType: normalized span type "${normalizedSpanType}" conflicts with "${conflictingTool}".`);
+    return;
+  }
+  toolBySpanType.set(normalizedSpanType, toolName);
+  return normalizedSpanType;
+}
+function buildToolSpanTypes(toolSchemas) {
+  if (!toolSchemas) {
+    return;
+  }
+  return Object.fromEntries(Object.entries(toolSchemas).map(([toolName, config]) => [toolName, config.spanType]));
+}
+function cloneRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return { ...value };
+}
+function stripToolSchemas(baseSchema) {
+  if (!baseSchema || typeof baseSchema !== "object" || Array.isArray(baseSchema)) {
+    return baseSchema;
+  }
+  const { toolSchemas: _, ...rest } = baseSchema;
+  return rest;
+}
+function mergeWithDefaultAgentSchema(baseSchema, defaultAgentSchema) {
+  if (!baseSchema) {
+    return defaultAgentSchema;
+  }
+  return {
+    ...defaultAgentSchema,
+    ...baseSchema,
+    span_schemas: {
+      ...cloneRecord(defaultAgentSchema.span_schemas),
+      ...cloneRecord(baseSchema.span_schemas)
+    },
+    span_result_schemas: {
+      ...cloneRecord(defaultAgentSchema.span_result_schemas),
+      ...cloneRecord(baseSchema.span_result_schemas)
+    }
+  };
+}
+function normalizeToolSpanType(spanType, toolName, providerName) {
+  const trimmedSpanType = spanType.trim();
+  if (trimmedSpanType.length === 0) {
+    logger2.warn(`Invalid agentSchema.toolSchemas.${toolName}.spanType: expected a non-empty string.`);
+    return;
+  }
+  const providerToolPrefix = `${providerName}:tool:`;
+  if (trimmedSpanType.startsWith(providerToolPrefix)) {
+    const suffix2 = trimmedSpanType.slice(providerToolPrefix.length).replace(/^:+/, "");
+    if (suffix2.length === 0) {
+      logger2.warn(`Invalid agentSchema.toolSchemas.${toolName}.spanType: expected a non-empty suffix after normalization.`);
+      return;
+    }
+    return `${providerName}:tool:${suffix2}`;
+  }
+  let suffix = trimmedSpanType;
+  if (suffix.startsWith(`${providerName}:`)) {
+    suffix = suffix.slice(`${providerName}:`.length);
+  }
+  if (suffix.startsWith("tool:")) {
+    suffix = suffix.slice("tool:".length);
+  }
+  suffix = suffix.replace(/^:+/, "");
+  if (suffix.length === 0) {
+    logger2.warn(`Invalid agentSchema.toolSchemas.${toolName}.spanType: expected a non-empty suffix after normalization.`);
+    return;
+  }
+  return `${providerName}:tool:${suffix}`;
+}
 // packages/core/src/utils/serialization.ts
 function truncateString(value, maxLength) {
   if (value.length <= maxLength) {
@@ -1236,7 +1438,9 @@ export {
   truncateString,
   shutdown,
   serializeValue,
+  resolveMappedSpanType,
   registerShutdownHandler,
+  normalizeAgentToolSchemas,
   init,
   getLogger,
   getClient,
@@ -1260,4 +1464,4 @@ export {
   AgentInstanceClient
 };
 
-//# debugId=4E7D6B116785760064756E2164756E21
+//# debugId=35742D945196233D64756E2164756E21