@inkeep/agents-core 0.0.0-chat-to-edit-20251119071712

package/dist/chunk-CMNLBV2A.js

@@ -0,0 +1,39 @@
+// src/types/a2a.ts
+var TaskState = /* @__PURE__ */ ((TaskState2) => {
+  TaskState2["Submitted"] = "submitted";
+  TaskState2["Working"] = "working";
+  TaskState2["InputRequired"] = "input-required";
+  TaskState2["Completed"] = "completed";
+  TaskState2["Canceled"] = "canceled";
+  TaskState2["Failed"] = "failed";
+  TaskState2["Rejected"] = "rejected";
+  TaskState2["AuthRequired"] = "auth-required";
+  TaskState2["Unknown"] = "unknown";
+  return TaskState2;
+})(TaskState || {});
+
+// src/types/tool-policies.ts
+function normalizeToolSelections(selections) {
+  if (!selections || selections.length === 0) {
+    return { selectedTools: [], toolPolicies: {} };
+  }
+  const selectedTools = [];
+  const toolPolicies = {};
+  for (const selection of selections) {
+    if (typeof selection === "string") {
+      selectedTools.push(selection);
+    } else {
+      selectedTools.push(selection.name);
+      const policy = {};
+      if (selection.needsApproval !== void 0) {
+        policy.needsApproval = selection.needsApproval;
+      }
+      if (Object.keys(policy).length > 0) {
+        toolPolicies[selection.name] = policy;
+      }
+    }
+  }
+  return { selectedTools, toolPolicies };
+}
+
+export { TaskState, normalizeToolSelections };

package/dist/chunk-E6R6PML7.js

@@ -0,0 +1,19 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+export { __commonJS, __export, __publicField, __require };

package/dist/chunk-OP3KPT4T.js

@@ -0,0 +1,442 @@
+import { registerClient, startAuthorization, exchangeAuthorization, discoverOAuthProtectedResourceMetadata, discoverAuthorizationServerMetadata } from '@modelcontextprotocol/sdk/client/auth.js';
+
+// src/constants/otel-attributes.ts
+var DELEGATION_FROM_SUB_AGENT_ID = "delegation.from_sub_agent_id";
+var DELEGATION_TO_SUB_AGENT_ID = "delegation.to_sub_agent_id";
+var DELEGATION_ID = "delegation.id";
+var TRANSFER_FROM_SUB_AGENT_ID = "transfer.from_sub_agent_id";
+var TRANSFER_TO_SUB_AGENT_ID = "transfer.to_sub_agent_id";
+var SPAN_NAMES = {
+  AI_TOOL_CALL: "ai.toolCall",
+  CONTEXT_RESOLUTION: "context-resolver.resolve_single_fetch_definition",
+  CONTEXT_HANDLE: "context.handle_context_resolution",
+  AGENT_GENERATION: "agent.generate",
+  CONTEXT_FETCHER: "context-fetcher.http-request",
+  ARTIFACT_PROCESSING: "agent_session.process_artifact"
+};
+var AI_OPERATIONS = {
+  GENERATE_TEXT: "ai.generateText.doGenerate",
+  STREAM_TEXT: "ai.streamText.doStream",
+  STREAM_OBJECT: "ai.streamObject.doStream"
+};
+var SPAN_KEYS = {
+  // Core span attributes
+  SPAN_ID: "spanID",
+  TRACE_ID: "traceID",
+  DURATION_NANO: "durationNano",
+  TIMESTAMP: "timestamp",
+  HAS_ERROR: "hasError",
+  STATUS_MESSAGE: "status_message",
+  OTEL_STATUS_CODE: "otel.status_code",
+  OTEL_STATUS_DESCRIPTION: "otel.status_description",
+  // Agent attributesa
+  AGENT_ID: "agent.id",
+  AGENT_NAME: "agent.name",
+  TENANT_ID: "tenant.id",
+  PROJECT_ID: "project.id",
+  SUB_AGENT_NAME: "subAgent.name",
+  SUB_AGENT_ID: "subAgent.id",
+  // AI/Agent attributes
+  AI_OPERATION_ID: "ai.operationId",
+  AI_RESPONSE_TIMESTAMP: "ai.response.timestamp",
+  AI_RESPONSE_CONTENT: "ai.response.content",
+  AI_RESPONSE_TEXT: "ai.response.text",
+  AI_RESPONSE_OBJECT: "ai.response.object",
+  AI_RESPONSE_MODEL: "ai.response.model",
+  AI_RESPONSE_TOOL_CALLS: "ai.response.toolCalls",
+  AI_PROMPT_MESSAGES: "ai.prompt.messages",
+  AI_MODEL_PROVIDER: "ai.model.provider",
+  AI_TELEMETRY_FUNCTION_ID: "ai.telemetry.functionId",
+  AI_TELEMETRY_SUB_AGENT_ID: "ai.telemetry.metadata.subAgentId",
+  AI_TELEMETRY_SUB_AGENT_NAME: "ai.telemetry.metadata.subAgentName",
+  AI_MODEL_ID: "ai.model.id",
+  // Tool attributes
+  AI_TOOL_CALL_NAME: "ai.toolCall.name",
+  AI_TOOL_CALL_RESULT: "ai.toolCall.result",
+  AI_TOOL_CALL_ARGS: "ai.toolCall.args",
+  AI_TOOL_CALL_ID: "ai.toolCall.id",
+  AI_TOOL_TYPE: "ai.toolType",
+  TOOL_PURPOSE: "tool.purpose",
+  // Token usage
+  GEN_AI_USAGE_INPUT_TOKENS: "gen_ai.usage.input_tokens",
+  GEN_AI_USAGE_OUTPUT_TOKENS: "gen_ai.usage.output_tokens",
+  // Context attributes
+  CONTEXT_URL: "context.url",
+  CONTEXT_CONFIG_ID: "context.context_config_id",
+  CONTEXT_AGENT_ID: "context.agent_id",
+  CONTEXT_HEADERS_KEYS: "context.headers_keys",
+  // Message attributes
+  MESSAGE_CONTENT: "message.content",
+  MESSAGE_TIMESTAMP: "message.timestamp",
+  MCP_TOOL_DESCRIPTION: "mcp.tool.description",
+  // Delegation/Transfer attributes
+  DELEGATION_FROM_SUB_AGENT_ID,
+  DELEGATION_TO_SUB_AGENT_ID,
+  DELEGATION_ID,
+  TRANSFER_FROM_SUB_AGENT_ID,
+  TRANSFER_TO_SUB_AGENT_ID,
+  // HTTP attributes
+  HTTP_URL: "http.url",
+  HTTP_STATUS_CODE: "http.status_code",
+  HTTP_RESPONSE_BODY_SIZE: "http.response.body_size",
+  // Core attributes
+  NAME: "name",
+  PARENT_SPAN_ID: "parentSpanID",
+  CONVERSATION_ID: "conversation.id",
+  // Artifact processing attributes
+  ARTIFACT_ID: "artifact.id",
+  ARTIFACT_TYPE: "artifact.type",
+  ARTIFACT_TOOL_CALL_ID: "artifact.tool_call_id",
+  ARTIFACT_DATA: "artifact.data",
+  ARTIFACT_NAME: "artifact.name",
+  ARTIFACT_DESCRIPTION: "artifact.description"
+};
+var UNKNOWN_VALUE = "unknown";
+var ACTIVITY_TYPES = {
+  TOOL_CALL: "tool_call",
+  AI_GENERATION: "ai_generation",
+  AGENT_GENERATION: "agent_generation",
+  CONTEXT_FETCH: "context_fetch",
+  CONTEXT_RESOLUTION: "context_resolution",
+  USER_MESSAGE: "user_message",
+  AI_ASSISTANT_MESSAGE: "ai_assistant_message",
+  AI_MODEL_STREAMED_TEXT: "ai_model_streamed_text",
+  AI_MODEL_STREAMED_OBJECT: "ai_model_streamed_object"
+};
+var ACTIVITY_STATUS = {
+  SUCCESS: "success",
+  ERROR: "error",
+  PENDING: "pending"
+};
+var AGENT_IDS = {
+  USER: "user",
+  AI_ASSISTANT: "ai-assistant"
+};
+var ACTIVITY_NAMES = {
+  CONTEXT_FETCH: "Context Fetch",
+  USER_MESSAGE: "User Message",
+  AI_ASSISTANT_MESSAGE: "AI Assistant Message",
+  AI_TEXT_GENERATION: "AI Text Generation",
+  AI_STREAMING_TEXT: "AI Streaming Text",
+  AI_STREAMING_OBJECT: "AI Streaming Object",
+  UNKNOWN_AGENT: "Unknown Agent",
+  USER: "User"
+};
+var AI_TOOL_TYPES = {
+  MCP: "mcp",
+  TRANSFER: "transfer",
+  DELEGATION: "delegation"
+};
+
+// src/constants/signoz-queries.ts
+var DATA_TYPES = {
+  STRING: "string",
+  INT64: "int64",
+  FLOAT64: "float64",
+  BOOL: "bool"
+};
+var FIELD_TYPES = {
+  TAG: "tag",
+  RESOURCE: "resource"
+};
+var QUERY_FIELD_CONFIGS = {
+  // String tag fields
+  STRING_TAG: {
+    dataType: DATA_TYPES.STRING,
+    type: FIELD_TYPES.TAG,
+    isColumn: false
+  },
+  STRING_TAG_COLUMN: {
+    dataType: DATA_TYPES.STRING,
+    type: FIELD_TYPES.TAG,
+    isColumn: true
+  },
+  // Numeric tag fields
+  INT64_TAG: {
+    dataType: DATA_TYPES.INT64,
+    type: FIELD_TYPES.TAG,
+    isColumn: false
+  },
+  INT64_TAG_COLUMN: {
+    dataType: DATA_TYPES.INT64,
+    type: FIELD_TYPES.TAG,
+    isColumn: true
+  },
+  FLOAT64_TAG: {
+    dataType: DATA_TYPES.FLOAT64,
+    type: FIELD_TYPES.TAG,
+    isColumn: false
+  },
+  FLOAT64_TAG_COLUMN: {
+    dataType: DATA_TYPES.FLOAT64,
+    type: FIELD_TYPES.TAG,
+    isColumn: true
+  },
+  // Boolean tag fields
+  BOOL_TAG: {
+    dataType: DATA_TYPES.BOOL,
+    type: FIELD_TYPES.TAG,
+    isColumn: false
+  },
+  BOOL_TAG_COLUMN: {
+    dataType: DATA_TYPES.BOOL,
+    type: FIELD_TYPES.TAG,
+    isColumn: true
+  }
+};
+var OPERATORS = {
+  // Comparison operators
+  EQUALS: "=",
+  NOT_EQUALS: "!=",
+  LESS_THAN: "<",
+  GREATER_THAN: ">",
+  LESS_THAN_OR_EQUAL: "<=",
+  GREATER_THAN_OR_EQUAL: ">=",
+  // String operators
+  LIKE: "like",
+  NOT_LIKE: "nlike",
+  // Existence operators
+  EXISTS: "exists",
+  NOT_EXISTS: "nexists",
+  // Set operators
+  IN: "in",
+  NOT_IN: "nin",
+  // Logical operators
+  AND: "AND",
+  OR: "OR"
+};
+var QUERY_EXPRESSIONS = {
+  SPAN_NAMES: "spanNames",
+  AGENT_MODEL_CALLS: "agentModelCalls",
+  MODEL_CALLS: "modelCalls",
+  LAST_ACTIVITY: "lastActivity",
+  CONVERSATION_METADATA: "conversationMetadata",
+  FILTERED_CONVERSATIONS: "filteredConversations",
+  TOOLS: "tools",
+  TRANSFERS: "transfers",
+  DELEGATIONS: "delegations",
+  AI_CALLS: "aiCalls",
+  CONTEXT_ERRORS: "contextErrors",
+  AGENT_GENERATION_ERRORS: "agentGenerationErrors",
+  USER_MESSAGES: "userMessages",
+  UNIQUE_AGENTS: "uniqueAgents",
+  UNIQUE_MODELS: "uniqueModels",
+  // Route-specific query names
+  TOOL_CALLS: "toolCalls",
+  CONTEXT_RESOLUTION: "contextResolution",
+  CONTEXT_HANDLE: "contextHandle",
+  AI_ASSISTANT_MESSAGES: "aiAssistantMessages",
+  AI_GENERATIONS: "aiGenerations",
+  AI_STREAMING_TEXT: "aiStreamingText",
+  AI_STREAMING_OBJECT: "aiStreamingObject",
+  CONTEXT_FETCHERS: "contextFetchers",
+  DURATION_SPANS: "durationSpans",
+  AGENT_GENERATIONS: "agentGenerations",
+  SPANS_WITH_ERRORS: "spansWithErrors",
+  ARTIFACT_PROCESSING: "artifactProcessing"
+};
+var REDUCE_OPERATIONS = {
+  SUM: "sum",
+  MAX: "max",
+  MIN: "min",
+  AVG: "avg",
+  COUNT: "count"
+};
+var ORDER_DIRECTIONS = {
+  ASC: "asc",
+  DESC: "desc"
+};
+var QUERY_TYPES = {
+  BUILDER: "builder",
+  CLICKHOUSE: "clickhouse",
+  PROMQL: "promql"
+};
+var PANEL_TYPES = {
+  LIST: "list",
+  TABLE: "table",
+  AGENT: "agent",
+  VALUE: "value"
+};
+var DATA_SOURCES = {
+  TRACES: "traces",
+  METRICS: "metrics",
+  LOGS: "logs"
+};
+var AGGREGATE_OPERATORS = {
+  COUNT: "count",
+  COUNT_DISTINCT: "count_distinct",
+  SUM: "sum",
+  AVG: "avg",
+  MIN: "min",
+  MAX: "max",
+  NOOP: "noop"
+};
+var QUERY_DEFAULTS = {
+  STEP: 60,
+  STEP_INTERVAL: 60,
+  OFFSET: 0,
+  DISABLED: false,
+  HAVING: [],
+  LEGEND: "",
+  LIMIT_UNLIMITED: 1e4,
+  EMPTY_GROUP_BY: []
+};
+function discoverScopes(resourceMetadata, metadata) {
+  const resourceScopes = resourceMetadata?.scopes_supported;
+  const oauthScopes = metadata?.scopes_supported;
+  const scopes = (resourceScopes?.length ? resourceScopes : oauthScopes) || [];
+  return scopes.length > 0 ? scopes.join(" ") : void 0;
+}
+async function discoverMcpMetadata(mcpServerUrl, logger) {
+  try {
+    let resourceMetadata = null;
+    let authServerUrl = new URL(mcpServerUrl);
+    try {
+      resourceMetadata = await discoverOAuthProtectedResourceMetadata(mcpServerUrl);
+      if (resourceMetadata?.authorization_servers?.length && resourceMetadata.authorization_servers[0]) {
+        authServerUrl = new URL(resourceMetadata.authorization_servers[0]);
+      }
+    } catch {
+    }
+    const metadata = await discoverAuthorizationServerMetadata(authServerUrl.href);
+    if (!metadata) {
+      throw new Error("Failed to discover OAuth authorization server metadata");
+    }
+    logger?.debug(
+      {
+        tokenEndpoint: metadata.token_endpoint,
+        authEndpoint: metadata.authorization_endpoint
+      },
+      "MCP metadata discovery successful"
+    );
+    const discoveredScopes = discoverScopes(resourceMetadata ?? void 0, metadata);
+    return {
+      success: true,
+      metadata,
+      ...resourceMetadata && { resourceMetadata },
+      ...discoveredScopes && { scopes: discoveredScopes }
+    };
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    logger?.debug({ error: errorMessage }, "MCP metadata discovery failed");
+    return { success: false, error: errorMessage };
+  }
+}
+async function initiateMcpOAuthFlow({
+  mcpServerUrl,
+  redirectUri,
+  state,
+  clientName = "Inkeep Agent Framework",
+  clientUri = "https://inkeep.com",
+  logoUri,
+  defaultClientId = "mcp-client",
+  logger
+}) {
+  const discoveryResult = await discoverMcpMetadata(mcpServerUrl, logger);
+  if (!discoveryResult.success || !discoveryResult.metadata) {
+    throw new Error(`OAuth not supported by this server: ${discoveryResult.error}`);
+  }
+  const { metadata, resourceMetadata, scopes: discoveredScopes } = discoveryResult;
+  const clientMetadata = {
+    redirect_uris: [redirectUri],
+    token_endpoint_auth_method: "none",
+    // PKCE - no client secret
+    grant_types: ["authorization_code", "refresh_token"],
+    response_types: ["code"],
+    client_name: clientName,
+    client_uri: clientUri,
+    ...logoUri && { logo_uri: logoUri }
+  };
+  let clientInformation;
+  if (metadata.registration_endpoint) {
+    clientInformation = await registerClient(mcpServerUrl, {
+      metadata,
+      clientMetadata
+    });
+  } else {
+    clientInformation = {
+      client_id: defaultClientId,
+      ...clientMetadata
+    };
+  }
+  const resource = resourceMetadata?.resource ? new globalThis.URL(resourceMetadata.resource) : void 0;
+  const authResult = await startAuthorization(mcpServerUrl, {
+    metadata,
+    clientInformation,
+    redirectUrl: redirectUri,
+    state,
+    scope: discoveredScopes || "",
+    ...resource && { resource }
+  });
+  logger?.debug(
+    {
+      authorizationUrl: authResult.authorizationUrl.href,
+      scopes: discoveredScopes,
+      clientId: clientInformation.client_id
+    },
+    "MCP OAuth flow initiated successfully"
+  );
+  return {
+    authorizationUrl: authResult.authorizationUrl.href,
+    codeVerifier: authResult.codeVerifier,
+    state,
+    clientInformation,
+    metadata,
+    resourceUrl: resource?.href || void 0,
+    ...discoveredScopes && { scopes: discoveredScopes }
+  };
+}
+async function exchangeMcpAuthorizationCode({
+  mcpServerUrl,
+  metadata,
+  clientInformation,
+  authorizationCode,
+  codeVerifier,
+  redirectUri,
+  resourceUrl,
+  logger
+}) {
+  const resource = resourceUrl ? new globalThis.URL(resourceUrl) : void 0;
+  const tokens = await exchangeAuthorization(mcpServerUrl, {
+    metadata,
+    clientInformation,
+    authorizationCode,
+    codeVerifier,
+    redirectUri,
+    ...resource && { resource }
+  });
+  logger?.debug(
+    {
+      tokenType: tokens.token_type,
+      hasRefreshToken: !!tokens.refresh_token,
+      expiresIn: tokens.expires_in
+    },
+    "MCP token exchange successful"
+  );
+  return {
+    access_token: tokens.access_token,
+    refresh_token: tokens.refresh_token,
+    expires_at: tokens.expires_in ? new Date(Date.now() + tokens.expires_in * 1e3) : void 0,
+    token_type: tokens.token_type || "Bearer",
+    scope: tokens.scope
+  };
+}
+var detectAuthenticationRequired = async ({
+  serverUrl,
+  error,
+  logger
+}) => {
+  try {
+    const discoveryResult = await discoverMcpMetadata(serverUrl, logger);
+    if (discoveryResult.success && discoveryResult.metadata) {
+      logger?.info({ serverUrl }, "MCP OAuth support confirmed via metadata discovery");
+      return true;
+    }
+  } catch (discoveryError) {
+    logger?.debug({ discoveryError }, "MCP OAuth metadata discovery failed");
+  }
+  logger?.debug({ error: error?.message }, "No MCP OAuth authentication requirement detected");
+  return false;
+};
+
+export { ACTIVITY_NAMES, ACTIVITY_STATUS, ACTIVITY_TYPES, AGENT_IDS, AGGREGATE_OPERATORS, AI_OPERATIONS, AI_TOOL_TYPES, DATA_SOURCES, DATA_TYPES, DELEGATION_FROM_SUB_AGENT_ID, DELEGATION_ID, DELEGATION_TO_SUB_AGENT_ID, FIELD_TYPES, OPERATORS, ORDER_DIRECTIONS, PANEL_TYPES, QUERY_DEFAULTS, QUERY_EXPRESSIONS, QUERY_FIELD_CONFIGS, QUERY_TYPES, REDUCE_OPERATIONS, SPAN_KEYS, SPAN_NAMES, TRANSFER_FROM_SUB_AGENT_ID, TRANSFER_TO_SUB_AGENT_ID, UNKNOWN_VALUE, detectAuthenticationRequired, exchangeMcpAuthorizationCode, initiateMcpOAuthFlow };