@inkeep/agents-sdk 0.38.3 → 0.39.0

package/dist/index.cjs

@@ -36,7 +36,12 @@ var lockfile__namespace = /*#__PURE__*/_interopNamespace(lockfile);
 var yaml__namespace = /*#__PURE__*/_interopNamespace(yaml);
 var ts__default = /*#__PURE__*/_interopDefault(ts);
 
-// src/index.ts
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/utils/generateIdFromName.ts
 function generateIdFromName(name) {
@@ -3565,6 +3570,209 @@ function transfer(targetAgent, description, condition) {
   return config;
 }
 
+// src/credential-provider.ts
+var DEFAULT_CONFIG = {
+  type: "memory",
+  id: "memory-default"
+};
+var InMemoryStore = class {
+  id;
+  type = "memory";
+  credentials = /* @__PURE__ */ new Map();
+  constructor(id = "memory-default") {
+    this.id = id;
+  }
+  async get(key) {
+    const credential2 = this.credentials.get(key);
+    if (!credential2) {
+      const envValue = process.env[key];
+      if (envValue) {
+        this.credentials.set(key, envValue);
+        return envValue;
+      }
+      return null;
+    }
+    return credential2;
+  }
+  async set(key, value, _metadata) {
+    this.credentials.set(key, value);
+  }
+  async has(key) {
+    return this.credentials.has(key) || !!process.env[key];
+  }
+  async delete(key) {
+    return this.credentials.delete(key);
+  }
+  async checkAvailability() {
+    return { available: true };
+  }
+};
+var InkeepCredentialProvider = class {
+  store;
+  constructor(config = DEFAULT_CONFIG) {
+    this.store = this.createStore(config);
+  }
+  /**
+   * Create the appropriate store based on configuration
+   */
+  createStore(config) {
+    switch (config.type) {
+      case "memory":
+        return new InMemoryStore(config.id);
+      case "keychain":
+        return this.createKeychainStore(config);
+      case "nango":
+        return this.createNangoStore(config);
+      case "custom":
+        return config.store;
+      default:
+        throw new Error(`Unknown credential provider type: ${config.type}`);
+    }
+  }
+  /**
+   * Create keychain store with dynamic import
+   */
+  createKeychainStore(config) {
+    const storeId = config.id || "keychain-default";
+    return {
+      id: storeId,
+      type: "keychain",
+      get: async (key) => {
+        const { createKeyChainStore } = await import('@inkeep/agents-core/credential-stores');
+        const store = createKeyChainStore(storeId);
+        return store.get(key);
+      },
+      set: async (key, value, metadata) => {
+        const { createKeyChainStore } = await import('@inkeep/agents-core/credential-stores');
+        const store = createKeyChainStore(storeId);
+        return store.set(key, value, metadata);
+      },
+      has: async (key) => {
+        const { createKeyChainStore } = await import('@inkeep/agents-core/credential-stores');
+        const store = createKeyChainStore(storeId);
+        return store.has(key);
+      },
+      delete: async (key) => {
+        const { createKeyChainStore } = await import('@inkeep/agents-core/credential-stores');
+        const store = createKeyChainStore(storeId);
+        return store.delete(key);
+      },
+      checkAvailability: async () => {
+        try {
+          const { createKeyChainStore } = await import('@inkeep/agents-core/credential-stores');
+          const store = createKeyChainStore(storeId);
+          return store.checkAvailability();
+        } catch {
+          return {
+            available: false,
+            reason: "Keychain store requires keytar package to be installed"
+          };
+        }
+      }
+    };
+  }
+  /**
+   * Create Nango store with dynamic import
+   */
+  createNangoStore(config) {
+    const storeId = config.id || "nango-default";
+    const secretKey = config.secretKey;
+    const apiUrl = config.apiUrl;
+    return {
+      id: storeId,
+      type: "nango",
+      get: async (key) => {
+        const { createNangoCredentialStore } = await import('@inkeep/agents-core/credential-stores');
+        const store = createNangoCredentialStore(storeId, { secretKey, apiUrl });
+        return store.get(key);
+      },
+      set: async (key, value, metadata) => {
+        const { createNangoCredentialStore } = await import('@inkeep/agents-core/credential-stores');
+        const store = createNangoCredentialStore(storeId, { secretKey, apiUrl });
+        return store.set(key, value, metadata);
+      },
+      has: async (key) => {
+        const { createNangoCredentialStore } = await import('@inkeep/agents-core/credential-stores');
+        const store = createNangoCredentialStore(storeId, { secretKey, apiUrl });
+        return store.has(key);
+      },
+      delete: async (key) => {
+        const { createNangoCredentialStore } = await import('@inkeep/agents-core/credential-stores');
+        const store = createNangoCredentialStore(storeId, { secretKey, apiUrl });
+        return store.delete(key);
+      },
+      checkAvailability: async () => {
+        try {
+          const { createNangoCredentialStore } = await import('@inkeep/agents-core/credential-stores');
+          const store = createNangoCredentialStore(storeId, { secretKey, apiUrl });
+          return store.checkAvailability();
+        } catch (error) {
+          return {
+            available: false,
+            reason: error instanceof Error ? error.message : "Nango store requires @nangohq/node package and NANGO_SECRET_KEY"
+          };
+        }
+      }
+    };
+  }
+  // Implement CredentialStore interface by delegating to internal store
+  get id() {
+    return this.store.id;
+  }
+  get type() {
+    return this.store.type;
+  }
+  /**
+   * Get a credential by key
+   * @param key - The credential key
+   * @returns The credential value or null if not found
+   */
+  async get(key) {
+    return this.store.get(key);
+  }
+  /**
+   * Set a credential
+   * @param key - The credential key
+   * @param value - The credential value
+   * @param metadata - Optional metadata
+   */
+  async set(key, value, metadata) {
+    return this.store.set(key, value, metadata);
+  }
+  /**
+   * Check if a credential exists
+   * @param key - The credential key
+   * @returns True if the credential exists
+   */
+  async has(key) {
+    return this.store.has(key);
+  }
+  /**
+   * Delete a credential
+   * @param key - The credential key
+   * @returns True if the credential was deleted
+   */
+  async delete(key) {
+    return this.store.delete(key);
+  }
+  /**
+   * Check if the credential store is available and functional
+   * @returns Availability status
+   */
+  async checkAvailability() {
+    return this.store.checkAvailability();
+  }
+  /**
+   * Get the underlying store (for advanced use cases)
+   */
+  getStore() {
+    return this.store;
+  }
+};
+function createCredentialProvider(config = DEFAULT_CONFIG) {
+  return new InkeepCredentialProvider(config);
+}
+
 // src/credential-ref.ts
 function credentialRef(id) {
   return {
@@ -3991,6 +4199,341 @@ var run = Runner.run.bind(Runner);
 var stream = Runner.stream.bind(Runner);
 var raceAgents = Runner.raceAgents.bind(Runner);
 
+// src/telemetry-provider.ts
+var SpanStatus = {
+  OK: "ok",
+  ERROR: "error",
+  UNSET: "unset"
+};
+var createNoOpSpan = () => ({
+  setAttributes: function() {
+    return this;
+  },
+  setAttribute: function() {
+    return this;
+  },
+  recordException: function() {
+    return this;
+  },
+  setStatus: function() {
+    return this;
+  },
+  addEvent: function() {
+    return this;
+  },
+  end: () => {
+  },
+  isRecording: () => false,
+  updateName: function() {
+    return this;
+  }
+});
+var createNoOpTracer = () => ({
+  startActiveSpan(_name, arg1, arg2) {
+    const fn = typeof arg1 === "function" ? arg1 : arg2;
+    if (!fn) throw new Error("No callback function provided");
+    return fn(createNoOpSpan());
+  },
+  startSpan(_name, _options) {
+    return createNoOpSpan();
+  }
+});
+var createNoOpLogger = () => ({
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+});
+var createNoOpMetrics = () => ({
+  increment: () => {
+  },
+  gauge: () => {
+  },
+  histogram: () => {
+  }
+});
+var NoOpTelemetryProvider = class {
+  getTracer(_name, _version) {
+    return createNoOpTracer();
+  }
+  getLogger(_name) {
+    return createNoOpLogger();
+  }
+  getMetrics(_name) {
+    return createNoOpMetrics();
+  }
+  async shutdown() {
+  }
+  isEnabled() {
+    return false;
+  }
+};
+var ConsoleTelemetryProvider = class {
+  serviceName;
+  constructor(serviceName = "inkeep-agent") {
+    this.serviceName = serviceName;
+  }
+  getTracer(name, _version) {
+    const serviceName = this.serviceName;
+    const createConsoleSpan = (spanName) => {
+      const startTime = Date.now();
+      const attributes = {};
+      const events = [];
+      return {
+        setAttributes: function(attrs) {
+          Object.assign(attributes, attrs);
+          return this;
+        },
+        setAttribute: function(key, value) {
+          attributes[key] = value;
+          return this;
+        },
+        recordException: function(error) {
+          console.error(`[${serviceName}:${name}] Exception in ${spanName}:`, error.message);
+          return this;
+        },
+        setStatus: function(status, message) {
+          if (status === SpanStatus.ERROR) {
+            console.error(`[${serviceName}:${name}] ${spanName} ERROR:`, message);
+          }
+          return this;
+        },
+        addEvent: function(eventName, eventAttrs) {
+          events.push({ name: eventName, attributes: eventAttrs });
+          return this;
+        },
+        end: () => {
+          const duration = Date.now() - startTime;
+          console.log(`[${serviceName}:${name}] ${spanName} completed in ${duration}ms`, {
+            attributes,
+            events
+          });
+        },
+        isRecording: () => true,
+        updateName: function(newName) {
+          console.log(`[${serviceName}:${name}] Span renamed: ${spanName} -> ${newName}`);
+          return this;
+        }
+      };
+    };
+    return {
+      startActiveSpan(spanName, arg1, arg2) {
+        const fn = typeof arg1 === "function" ? arg1 : arg2;
+        if (!fn) throw new Error("No callback function provided");
+        const span = createConsoleSpan(spanName);
+        try {
+          return fn(span);
+        } finally {
+          span.end();
+        }
+      },
+      startSpan(spanName, _options) {
+        return createConsoleSpan(spanName);
+      }
+    };
+  }
+  getLogger(name) {
+    const prefix = `[${this.serviceName}:${name}]`;
+    return {
+      debug: (message, context) => console.debug(prefix, message, context),
+      info: (message, context) => console.info(prefix, message, context),
+      warn: (message, context) => console.warn(prefix, message, context),
+      error: (message, context) => console.error(prefix, message, context)
+    };
+  }
+  getMetrics(name) {
+    const prefix = `[${this.serviceName}:${name}]`;
+    return {
+      increment: (metricName, value = 1, attributes) => console.log(`${prefix} COUNTER ${metricName}: +${value}`, attributes),
+      gauge: (metricName, value, attributes) => console.log(`${prefix} GAUGE ${metricName}: ${value}`, attributes),
+      histogram: (metricName, value, attributes) => console.log(`${prefix} HISTOGRAM ${metricName}: ${value}`, attributes)
+    };
+  }
+  async shutdown() {
+    console.log(`[${this.serviceName}] Telemetry provider shutting down`);
+  }
+  isEnabled() {
+    return true;
+  }
+};
+var globalProvider = new NoOpTelemetryProvider();
+var InkeepTelemetryProvider = class {
+  provider;
+  constructor(config = {}) {
+    if (config.provider) {
+      this.provider = config.provider;
+    } else if (config.enabled) {
+      this.provider = new ConsoleTelemetryProvider(config.serviceName);
+    } else {
+      this.provider = new NoOpTelemetryProvider();
+    }
+  }
+  /**
+   * Get a tracer for creating spans
+   */
+  getTracer(name, version) {
+    return this.provider.getTracer(name, version);
+  }
+  /**
+   * Get a logger for structured logging
+   */
+  getLogger(name) {
+    return this.provider.getLogger(name);
+  }
+  /**
+   * Get metrics recorder
+   */
+  getMetrics(name) {
+    return this.provider.getMetrics(name);
+  }
+  /**
+   * Check if telemetry is enabled
+   */
+  isEnabled() {
+    return this.provider.isEnabled();
+  }
+  /**
+   * Shutdown the provider
+   */
+  async shutdown() {
+    return this.provider.shutdown();
+  }
+  /**
+   * Get the underlying provider
+   */
+  getProvider() {
+    return this.provider;
+  }
+  /**
+   * Set as the global telemetry provider
+   */
+  setAsGlobal() {
+    globalProvider = this.provider;
+  }
+};
+function getGlobalTelemetryProvider() {
+  return globalProvider;
+}
+function setGlobalTelemetryProvider(provider) {
+  globalProvider = provider;
+}
+function createNoOpTelemetryProvider() {
+  return new InkeepTelemetryProvider({ enabled: false });
+}
+function createConsoleTelemetryProvider(serviceName) {
+  return new InkeepTelemetryProvider({
+    enabled: true,
+    serviceName,
+    provider: new ConsoleTelemetryProvider(serviceName)
+  });
+}
+function wrapOtelSpan(otelSpan) {
+  return {
+    setAttributes: function(attributes) {
+      otelSpan.setAttributes(attributes);
+      return this;
+    },
+    setAttribute: function(key, value) {
+      otelSpan.setAttribute(key, value);
+      return this;
+    },
+    recordException: function(error) {
+      otelSpan.recordException(error);
+      return this;
+    },
+    setStatus: function(status, message) {
+      const statusCode = status === SpanStatus.ERROR ? 2 : status === SpanStatus.OK ? 1 : 0;
+      otelSpan.setStatus({ code: statusCode, message });
+      return this;
+    },
+    addEvent: function(name, attributes) {
+      otelSpan.addEvent(name, attributes);
+      return this;
+    },
+    end: () => otelSpan.end(),
+    isRecording: () => otelSpan.isRecording(),
+    updateName: function(name) {
+      otelSpan.updateName(name);
+      return this;
+    }
+  };
+}
+function isOpenTelemetryAvailable() {
+  try {
+    __require.resolve("@opentelemetry/api");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadOpenTelemetryModule() {
+  const dynamicImport = new Function("specifier", "return import(specifier)");
+  return dynamicImport("@opentelemetry/api");
+}
+async function createOpenTelemetryProvider(config) {
+  if (!isOpenTelemetryAvailable()) {
+    console.warn(
+      "OpenTelemetry packages not installed. Install with: npm install @opentelemetry/api @opentelemetry/sdk-node"
+    );
+    return createNoOpTelemetryProvider();
+  }
+  try {
+    const { trace } = await loadOpenTelemetryModule();
+    const provider = {
+      getTracer(name, version) {
+        const otelTracer = trace.getTracer(name, version);
+        return {
+          startActiveSpan(spanName, arg1, arg2) {
+            const fn = typeof arg1 === "function" ? arg1 : arg2;
+            const options = typeof arg1 === "object" ? arg1 : void 0;
+            if (!fn) throw new Error("No callback function provided");
+            return otelTracer.startActiveSpan(
+              spanName,
+              options?.attributes ? { attributes: options.attributes } : {},
+              (otelSpan) => {
+                const span = wrapOtelSpan(otelSpan);
+                return fn(span);
+              }
+            );
+          },
+          startSpan(spanName, options) {
+            const otelSpan = otelTracer.startSpan(
+              spanName,
+              options?.attributes ? { attributes: options.attributes } : {}
+            );
+            return wrapOtelSpan(otelSpan);
+          }
+        };
+      },
+      getLogger(name) {
+        return new ConsoleTelemetryProvider(config.serviceName).getLogger(name);
+      },
+      getMetrics(_name) {
+        return createNoOpMetrics();
+      },
+      async shutdown() {
+      },
+      isEnabled() {
+        return true;
+      }
+    };
+    return new InkeepTelemetryProvider({
+      enabled: true,
+      provider
+    });
+  } catch (error) {
+    console.warn(
+      "Failed to initialize OpenTelemetry:",
+      error instanceof Error ? error.message : "Unknown error"
+    );
+    return createNoOpTelemetryProvider();
+  }
+}
+
 Object.defineProperty(exports, "ANTHROPIC_MODELS", {
   enumerable: true,
   get: function () { return agentsCore.ANTHROPIC_MODELS; }
@@ -4004,19 +4547,28 @@ Object.defineProperty(exports, "OPENAI_MODELS", {
   get: function () { return agentsCore.OPENAI_MODELS; }
 });
 exports.ArtifactComponent = ArtifactComponent;
+exports.ConsoleTelemetryProvider = ConsoleTelemetryProvider;
 exports.DataComponent = DataComponent;
 exports.ExternalAgent = ExternalAgent;
 exports.FunctionTool = FunctionTool;
+exports.InkeepCredentialProvider = InkeepCredentialProvider;
+exports.InkeepTelemetryProvider = InkeepTelemetryProvider;
+exports.NoOpTelemetryProvider = NoOpTelemetryProvider;
 exports.Project = Project;
 exports.Runner = Runner;
+exports.SpanStatus = SpanStatus;
 exports.StatusComponent = StatusComponent;
 exports.SubAgent = SubAgent;
 exports.Tool = Tool;
 exports.agent = agent;
 exports.agentMcp = agentMcp;
 exports.artifactComponent = artifactComponent;
+exports.createConsoleTelemetryProvider = createConsoleTelemetryProvider;
+exports.createCredentialProvider = createCredentialProvider;
 exports.createEnvironmentSettings = createEnvironmentSettings;
 exports.createFullProjectViaAPI = createFullProjectViaAPI;
+exports.createNoOpTelemetryProvider = createNoOpTelemetryProvider;
+exports.createOpenTelemetryProvider = createOpenTelemetryProvider;
 exports.credential = credential;
 exports.credentialRef = credentialRef;
 exports.dataComponent = dataComponent;
@@ -4025,6 +4577,7 @@ exports.externalAgent = externalAgent;
 exports.externalAgents = externalAgents;
 exports.functionTool = functionTool;
 exports.getFullProjectViaAPI = getFullProjectViaAPI;
+exports.getGlobalTelemetryProvider = getGlobalTelemetryProvider;
 exports.isCredentialReference = isCredentialReference;
 exports.mcpServer = mcpServer;
 exports.mcpTool = mcpTool;
@@ -4032,6 +4585,7 @@ exports.project = project;
 exports.raceAgents = raceAgents;
 exports.registerEnvironmentSettings = registerEnvironmentSettings;
 exports.run = run;
+exports.setGlobalTelemetryProvider = setGlobalTelemetryProvider;
 exports.statusComponent = statusComponent;
 exports.stream = stream;
 exports.subAgent = subAgent;