@inkeep/agents-run-api 0.39.2 → 0.39.4

package/dist/chunk-KCJWSIDZ.js

@@ -1,246 +0,0 @@
-import { dbClient_default } from './chunk-EVOISBFH.js';
-import { CONVERSATION_HISTORY_DEFAULT_LIMIT } from './chunk-THWNUGWP.js';
-import { CONVERSATION_HISTORY_MAX_OUTPUT_TOKENS_DEFAULT, createMessage, generateId, getConversationHistory } from '@inkeep/agents-core';
-
-function createDefaultConversationHistoryConfig(mode = "full") {
-  return {
-    mode,
-    limit: CONVERSATION_HISTORY_DEFAULT_LIMIT,
-    includeInternal: true,
-    messageTypes: ["chat", "tool-result"],
-    maxOutputTokens: CONVERSATION_HISTORY_MAX_OUTPUT_TOKENS_DEFAULT
-  };
-}
-function extractA2AMessageText(parts) {
-  return parts.filter((part) => part.kind === "text" && part.text).map((part) => part.text).join("");
-}
-async function saveA2AMessageResponse(response, params) {
-  if (response.error) {
-    throw new Error(response.error.message);
-  }
-  let messageText = "";
-  if (response.result.kind === "message") {
-    messageText = extractA2AMessageText(response.result.parts);
-  } else if (response.result.kind === "task") {
-    if (response.result.artifacts && response.result.artifacts.length > 0) {
-      const firstArtifact = response.result.artifacts[0];
-      if (firstArtifact.parts) {
-        messageText = extractA2AMessageText(firstArtifact.parts);
-      }
-    }
-  } else if (typeof response.result === "string") {
-    messageText = response.result;
-  }
-  if (!messageText || messageText.trim() === "") {
-    return null;
-  }
-  return await createMessage(dbClient_default)({
-    id: generateId(),
-    tenantId: params.tenantId,
-    projectId: params.projectId,
-    conversationId: params.conversationId,
-    role: "agent",
-    content: {
-      text: messageText
-    },
-    visibility: params.visibility,
-    messageType: params.messageType,
-    fromSubAgentId: params.fromSubAgentId,
-    toSubAgentId: params.toSubAgentId,
-    fromExternalAgentId: params.fromExternalAgentId,
-    toExternalAgentId: params.toExternalAgentId,
-    a2aTaskId: params.a2aTaskId,
-    a2aSessionId: params.a2aSessionId,
-    metadata: params.metadata
-  });
-}
-async function getScopedHistory({
-  tenantId,
-  projectId,
-  conversationId,
-  filters,
-  options
-}) {
-  try {
-    const messages = await getConversationHistory(dbClient_default)({
-      scopes: { tenantId, projectId },
-      conversationId,
-      options
-    });
-    if (!filters || !filters.subAgentId && !filters.taskId && !filters.delegationId && filters.isDelegated === void 0) {
-      return messages;
-    }
-    const relevantMessages = messages.filter((msg) => {
-      if (msg.role === "user") return true;
-      let matchesAgent = true;
-      let matchesTask = true;
-      let matchesDelegation = true;
-      if (filters.subAgentId) {
-        matchesAgent = msg.role === "agent" && msg.visibility === "user-facing" || msg.toSubAgentId === filters.subAgentId || msg.fromSubAgentId === filters.subAgentId;
-      }
-      if (filters.taskId) {
-        matchesTask = msg.taskId === filters.taskId || msg.a2aTaskId === filters.taskId;
-      }
-      if (filters.delegationId !== void 0 || filters.isDelegated !== void 0) {
-        if (msg.messageType === "tool-result") {
-          const messageDelegationId = msg.metadata?.a2a_metadata?.delegationId;
-          const messageIsDelegated = msg.metadata?.a2a_metadata?.isDelegated;
-          if (filters.delegationId) {
-            matchesDelegation = messageDelegationId === filters.delegationId || !messageDelegationId;
-          } else if (filters.isDelegated === false) {
-            matchesDelegation = !messageIsDelegated;
-          } else if (filters.isDelegated === true) {
-            matchesDelegation = messageIsDelegated === true;
-          }
-        }
-      }
-      const conditions = [];
-      if (filters.subAgentId) conditions.push(matchesAgent);
-      if (filters.taskId) conditions.push(matchesTask);
-      if (filters.delegationId !== void 0 || filters.isDelegated !== void 0)
-        conditions.push(matchesDelegation);
-      const finalResult = conditions.length === 0 || conditions.every(Boolean);
-      return finalResult;
-    });
-    return relevantMessages;
-  } catch (error) {
-    console.error("Failed to fetch scoped messages:", error);
-    return [];
-  }
-}
-async function getUserFacingHistory(tenantId, projectId, conversationId, limit = CONVERSATION_HISTORY_DEFAULT_LIMIT) {
-  return await getConversationHistory(dbClient_default)({
-    scopes: { tenantId, projectId },
-    conversationId,
-    options: {
-      limit,
-      includeInternal: false,
-      messageTypes: ["chat"]
-    }
-  });
-}
-async function getFullConversationContext(tenantId, projectId, conversationId, maxTokens) {
-  const defaultConfig = createDefaultConversationHistoryConfig();
-  return await getConversationHistory(dbClient_default)({
-    scopes: { tenantId, projectId },
-    conversationId,
-    options: {
-      ...defaultConfig,
-      limit: 100,
-      includeInternal: true,
-      maxOutputTokens: maxTokens
-    }
-  });
-}
-async function getFormattedConversationHistory({
-  tenantId,
-  projectId,
-  conversationId,
-  currentMessage,
-  options,
-  filters
-}) {
-  const historyOptions = options ?? createDefaultConversationHistoryConfig();
-  const conversationHistory = await getScopedHistory({
-    tenantId,
-    projectId,
-    conversationId,
-    filters,
-    options: historyOptions
-  });
-  let messagesToFormat = conversationHistory;
-  if (currentMessage && conversationHistory.length > 0) {
-    const lastMessage = conversationHistory[conversationHistory.length - 1];
-    if (lastMessage.content.text === currentMessage) {
-      messagesToFormat = conversationHistory.slice(0, -1);
-    }
-  }
-  if (!messagesToFormat.length) {
-    return "";
-  }
-  const formattedHistory = messagesToFormat.map((msg) => {
-    let roleLabel;
-    if (msg.role === "user") {
-      roleLabel = "user";
-    } else if (msg.role === "agent" && (msg.messageType === "a2a-request" || msg.messageType === "a2a-response")) {
-      const fromSubAgent = msg.fromSubAgentId || msg.fromExternalAgentId || "unknown";
-      const toSubAgent = msg.toSubAgentId || msg.toExternalAgentId || "unknown";
-      roleLabel = `${fromSubAgent} to ${toSubAgent}`;
-    } else if (msg.role === "agent" && msg.messageType === "chat") {
-      const fromSubAgent = msg.fromSubAgentId || "unknown";
-      roleLabel = `${fromSubAgent} to User`;
-    } else if (msg.role === "assistant" && msg.messageType === "tool-result") {
-      const fromSubAgent = msg.fromSubAgentId || "unknown";
-      const toolName = msg.metadata?.a2a_metadata?.toolName || "unknown";
-      roleLabel = `${fromSubAgent} tool: ${toolName}`;
-    } else {
-      roleLabel = msg.role || "system";
-    }
-    return `${roleLabel}: """${msg.content.text}"""`;
-  }).join("\n");
-  return `<conversation_history>
-${formattedHistory}
-</conversation_history>
-`;
-}
-async function getConversationScopedArtifacts(params) {
-  const { tenantId, projectId, conversationId, historyConfig } = params;
-  if (!conversationId) {
-    return [];
-  }
-  try {
-    if (historyConfig.mode === "none") {
-      return [];
-    }
-    const visibleMessages = await getScopedHistory({
-      tenantId,
-      projectId,
-      conversationId,
-      options: historyConfig
-    });
-    if (visibleMessages.length === 0) {
-      return [];
-    }
-    const visibleMessageIds = visibleMessages.filter(
-      (msg) => !(msg.messageType === "system" && msg.content?.text?.includes("Previous conversation history truncated"))
-    ).map((msg) => msg.id);
-    if (visibleMessageIds.length === 0) {
-      return [];
-    }
-    const { getLedgerArtifacts } = await import('@inkeep/agents-core');
-    const dbClient = (await import('./dbClient-MAHUR4TO.js')).default;
-    const visibleTaskIds = visibleMessages.map((msg) => msg.taskId).filter((taskId) => Boolean(taskId));
-    const referenceArtifacts = [];
-    for (const taskId of visibleTaskIds) {
-      const artifacts = await getLedgerArtifacts(dbClient)({
-        scopes: { tenantId, projectId },
-        taskId
-      });
-      referenceArtifacts.push(...artifacts);
-    }
-    const logger = (await import('./logger-3EE6BUSU.js')).getLogger("conversations");
-    logger.debug(
-      {
-        conversationId,
-        visibleMessages: visibleMessages.length,
-        visibleTasks: visibleTaskIds.length,
-        artifacts: referenceArtifacts.length,
-        historyMode: historyConfig.mode
-      },
-      "Loaded conversation-scoped artifacts"
-    );
-    return referenceArtifacts;
-  } catch (error) {
-    const logger = (await import('./logger-3EE6BUSU.js')).getLogger("conversations");
-    logger.error(
-      {
-        error: error instanceof Error ? error.message : "Unknown error",
-        conversationId
-      },
-      "Failed to get conversation-scoped artifacts"
-    );
-    return [];
-  }
-}
-
-export { createDefaultConversationHistoryConfig, getConversationScopedArtifacts, getFormattedConversationHistory, getFullConversationContext, getScopedHistory, getUserFacingHistory, saveA2AMessageResponse };

package/dist/chunk-THWNUGWP.js

@@ -1,204 +0,0 @@
-import { z } from '@hono/zod-openapi';
-import { loadEnvironmentFiles } from '@inkeep/agents-core';
-
-// src/constants/execution-limits/index.ts
-
-// src/constants/execution-limits/defaults.ts
-var executionLimitsDefaults = {
-  // Sub Agent Turn Execution
-  // During a Sub Agent's turn, it makes decisions by calling the LLM (language model). Each decision
-  // point is called a "generation step" - for example, deciding to call a tool, transfer to another
-  // Sub Agent, delegate a subtask, or send a response to the user.
-  // AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS: Maximum errors tolerated during a single Sub Agent's turn before stopping execution
-  // AGENT_EXECUTION_MAX_GENERATION_STEPS: Maximum LLM inference calls allowed within a single Sub Agent turn
-  AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS: 3,
-  AGENT_EXECUTION_MAX_GENERATION_STEPS: 5,
-  // Sub Agent Decision-Making Timeouts
-  // These control how long to wait for the LLM to make decisions during a Sub Agent's turn.
-  // "First call" = initial decision at start of turn (may include tool results from previous actions)
-  // "Subsequent call" = follow-up decisions after executing tools within the same turn
-  // Streaming mode has longer timeout because it waits for the full streamed response to the user
-  // LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING: Timeout for initial streaming response to user
-  // LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING: Timeout for initial non-streaming (internal) decision
-  // LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS: Timeout for follow-up decisions after tool execution
-  // LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS: Maximum timeout allowed regardless of configuration
-  LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING: 27e4,
-  // 4.5 minutes
-  LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING: 9e4,
-  // 1.5 minutes
-  LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS: 9e4,
-  // 1.5 minutes
-  LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS: 6e5,
-  // 10 minutes
-  // Function Tool Execution (Sandboxed Environments)
-  // Function Tools are custom JavaScript functions that Sub Agents can call. They run in secure
-  // isolated sandboxes (containerized environments) to prevent malicious code execution.
-  // For performance, sandboxes are cached and reused across multiple tool calls until they expire.
-  // FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT: Maximum execution time for a Function Tool call
-  // FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT: Virtual CPUs allocated to each sandbox (affects compute capacity)
-  // FUNCTION_TOOL_SANDBOX_POOL_TTL_MS: Time-to-live for cached sandboxes (after this, sandbox is discarded)
-  // FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT: Maximum reuses of a sandbox before it's refreshed (prevents resource leaks)
-  // FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES: Maximum size of Function Tool output (prevents memory exhaustion)
-  // FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS: Maximum wait time for sandbox to become available when pool is full
-  // FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS: How often to check for and remove expired sandboxes from the pool
-  FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT: 3e4,
-  // 30 seconds
-  FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT: 4,
-  FUNCTION_TOOL_SANDBOX_POOL_TTL_MS: 3e5,
-  // 5 minutes
-  FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT: 50,
-  FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES: 1048576,
-  // 1 MB
-  FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS: 3e4,
-  // 30 seconds
-  FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS: 6e4,
-  // 1 minute
-  // MCP Tool Execution
-  // MCP (Model Context Protocol) Servers are external services that provide tools to Sub Agents.
-  // When a Sub Agent calls an MCP Tool, the request is sent to the external MCP Server.
-  // Note: MCP connection/retry constants are defined in @inkeep/agents-core/constants/execution-limits-shared
-  // MCP_TOOL_REQUEST_TIMEOUT_MS_DEFAULT: Maximum wait time for an MCP tool call to complete
-  MCP_TOOL_REQUEST_TIMEOUT_MS_DEFAULT: 6e4,
-  // 60 seconds
-  // Sub Agent Delegation (Retry Strategy)
-  // When a Sub Agent delegates a subtask to another Sub Agent, it uses the A2A (Agent-to-Agent)
-  // protocol to communicate. If the delegation request fails, these constants control the
-  // exponential backoff retry strategy. Formula: delay = min(INITIAL * EXPONENT^attempt, MAX)
-  // DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS: Starting delay before first retry
-  // DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS: Maximum delay between retries (caps exponential growth)
-  // DELEGATION_TOOL_BACKOFF_EXPONENT: Multiplier applied to delay after each retry (2 = doubles each time)
-  // DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS: Total time to keep retrying before giving up
-  DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS: 100,
-  DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS: 1e4,
-  // 10 seconds
-  DELEGATION_TOOL_BACKOFF_EXPONENT: 2,
-  DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS: 2e4,
-  // 20 seconds
-  // General Agent-to-Agent (A2A) Communication (Retry Strategy)
-  // These control retries for broader A2A protocol operations beyond delegation (e.g., status checks,
-  // conversation updates). Uses more conservative retry parameters than delegation-specific retries.
-  // A2A_BACKOFF_INITIAL_INTERVAL_MS: Starting delay before first retry
-  // A2A_BACKOFF_MAX_INTERVAL_MS: Maximum delay between retries
-  // A2A_BACKOFF_EXPONENT: Multiplier for exponential backoff (1.5 = grows 50% each retry)
-  // A2A_BACKOFF_MAX_ELAPSED_TIME_MS: Total time to keep retrying before giving up
-  A2A_BACKOFF_INITIAL_INTERVAL_MS: 500,
-  A2A_BACKOFF_MAX_INTERVAL_MS: 6e4,
-  // 1 minute
-  A2A_BACKOFF_EXPONENT: 1.5,
-  A2A_BACKOFF_MAX_ELAPSED_TIME_MS: 3e4,
-  // 30 seconds
-  // Artifact Processing
-  // Artifacts are tool outputs saved for later reference by Sub Agents or users. When a tool generates
-  // an artifact, the system automatically generates a human-readable name and description using the LLM.
-  // These constants control artifact name/description generation and context window management.
-  // ARTIFACT_GENERATION_MAX_RETRIES: Retry attempts for LLM-based artifact name/description generation
-  // ARTIFACT_SESSION_MAX_PENDING: Maximum unprocessed artifacts in queue (prevents unbounded growth)
-  // ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES: Historical artifact summaries kept in context for reference
-  // ARTIFACT_GENERATION_BACKOFF_INITIAL_MS: Starting delay for retry backoff when generation fails
-  // ARTIFACT_GENERATION_BACKOFF_MAX_MS: Maximum delay between retries (formula: min(INITIAL * 2^attempt, MAX))
-  ARTIFACT_GENERATION_MAX_RETRIES: 3,
-  ARTIFACT_SESSION_MAX_PENDING: 100,
-  ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES: 3,
-  ARTIFACT_GENERATION_BACKOFF_INITIAL_MS: 1e3,
-  // 1 second
-  ARTIFACT_GENERATION_BACKOFF_MAX_MS: 1e4,
-  // 10 seconds
-  // Conversation Session & Cache Management
-  // A "session" represents the state of an ongoing conversation with an Agent. Tool results are cached
-  // within the session for performance - this is especially important for artifact processing where the
-  // same tool outputs may be referenced multiple times across Sub Agent turns.
-  // SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS: How long tool results are kept in cache before expiring
-  // SESSION_CLEANUP_INTERVAL_MS: How often to check for and remove expired cached tool results
-  SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS: 3e5,
-  // 5 minutes
-  SESSION_CLEANUP_INTERVAL_MS: 6e4,
-  // 1 minute
-  // Status Updates
-  // Status Updates are real-time progress messages sent to users during longer Sub Agent operations.
-  // The system automatically generates status updates based on activity thresholds - either after a
-  // certain number of significant events OR after a time interval (whichever comes first).
-  // Events include: tool calls, Sub Agent transfers, delegations, or other significant activities.
-  // STATUS_UPDATE_DEFAULT_NUM_EVENTS: Number of significant events before triggering a status update
-  // STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS: Time interval (in seconds) before generating status update
-  STATUS_UPDATE_DEFAULT_NUM_EVENTS: 1,
-  STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS: 2,
-  // Response Streaming (Internal Buffering Limits)
-  // These are internal infrastructure limits for streaming responses to users. Streaming enables
-  // real-time updates as Sub Agents generate responses, Data Components, and Status Updates.
-  // STREAM_PARSER_MAX_SNAPSHOT_SIZE: Maximum Data Component snapshots buffered before clearing old ones
-  // STREAM_PARSER_MAX_STREAMED_SIZE: Maximum streamed component IDs tracked simultaneously
-  // STREAM_PARSER_MAX_COLLECTED_PARTS: Maximum accumulated stream parts before forcing flush
-  // STREAM_BUFFER_MAX_SIZE_BYTES: Maximum total buffer size in bytes (prevents memory exhaustion)
-  // STREAM_TEXT_GAP_THRESHOLD_MS: Time gap that triggers bundling text with artifact data vs separate send
-  // STREAM_MAX_LIFETIME_MS: Maximum duration a stream can stay open before forced closure
-  STREAM_PARSER_MAX_SNAPSHOT_SIZE: 100,
-  STREAM_PARSER_MAX_STREAMED_SIZE: 1e3,
-  STREAM_PARSER_MAX_COLLECTED_PARTS: 1e4,
-  STREAM_BUFFER_MAX_SIZE_BYTES: 5242880,
-  // 5 MB
-  STREAM_TEXT_GAP_THRESHOLD_MS: 2e3,
-  // 2 seconds
-  STREAM_MAX_LIFETIME_MS: 6e5,
-  // 10 minutes
-  // Conversation History Message Retrieval
-  // CONVERSATION_HISTORY_DEFAULT_LIMIT: Default number of recent conversation messages to retrieve
-  CONVERSATION_HISTORY_DEFAULT_LIMIT: 50
-};
-
-// src/constants/execution-limits/index.ts
-loadEnvironmentFiles();
-var constantsSchema = z.object(
-  Object.fromEntries(
-    Object.keys(executionLimitsDefaults).map((key) => [
-      `AGENTS_${key}`,
-      z.coerce.number().optional()
-    ])
-  )
-);
-var parseConstants = () => {
-  const envOverrides = constantsSchema.parse(process.env);
-  return Object.fromEntries(
-    Object.entries(executionLimitsDefaults).map(([key, defaultValue]) => [
-      key,
-      envOverrides[`AGENTS_${key}`] ?? defaultValue
-    ])
-  );
-};
-var constants = parseConstants();
-var {
-  AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS,
-  AGENT_EXECUTION_MAX_GENERATION_STEPS,
-  LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING,
-  LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING,
-  LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS,
-  LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS,
-  FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT,
-  FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT,
-  FUNCTION_TOOL_SANDBOX_POOL_TTL_MS,
-  FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT,
-  FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES,
-  FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS,
-  FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS,
-  DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS,
-  DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS,
-  DELEGATION_TOOL_BACKOFF_EXPONENT,
-  DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS,
-  ARTIFACT_GENERATION_MAX_RETRIES,
-  ARTIFACT_SESSION_MAX_PENDING,
-  ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES,
-  ARTIFACT_GENERATION_BACKOFF_INITIAL_MS,
-  ARTIFACT_GENERATION_BACKOFF_MAX_MS,
-  SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS,
-  SESSION_CLEANUP_INTERVAL_MS,
-  STATUS_UPDATE_DEFAULT_NUM_EVENTS,
-  STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS,
-  STREAM_PARSER_MAX_SNAPSHOT_SIZE,
-  STREAM_PARSER_MAX_STREAMED_SIZE,
-  STREAM_PARSER_MAX_COLLECTED_PARTS,
-  STREAM_BUFFER_MAX_SIZE_BYTES,
-  STREAM_TEXT_GAP_THRESHOLD_MS,
-  STREAM_MAX_LIFETIME_MS,
-  CONVERSATION_HISTORY_DEFAULT_LIMIT
-} = constants;
-
-export { AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS, AGENT_EXECUTION_MAX_GENERATION_STEPS, ARTIFACT_GENERATION_BACKOFF_INITIAL_MS, ARTIFACT_GENERATION_BACKOFF_MAX_MS, ARTIFACT_GENERATION_MAX_RETRIES, ARTIFACT_SESSION_MAX_PENDING, ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES, CONVERSATION_HISTORY_DEFAULT_LIMIT, DELEGATION_TOOL_BACKOFF_EXPONENT, DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS, DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS, DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS, FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES, FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT, FUNCTION_TOOL_SANDBOX_POOL_TTL_MS, FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS, FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS, LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS, SESSION_CLEANUP_INTERVAL_MS, SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS, STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS, STATUS_UPDATE_DEFAULT_NUM_EVENTS, STREAM_BUFFER_MAX_SIZE_BYTES, STREAM_MAX_LIFETIME_MS, STREAM_PARSER_MAX_COLLECTED_PARTS, STREAM_PARSER_MAX_SNAPSHOT_SIZE, STREAM_PARSER_MAX_STREAMED_SIZE, STREAM_TEXT_GAP_THRESHOLD_MS };

package/dist/chunk-UC2EPLSW.js

@@ -1,75 +0,0 @@
-import { env } from './chunk-KBZIYCPJ.js';
-import { getLogger } from './chunk-A2S7GSHL.js';
-import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
-import { BaggageSpanProcessor, ALLOW_ALL_BAGGAGE_KEYS } from '@opentelemetry/baggage-span-processor';
-import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
-import { CompositePropagator, W3CTraceContextPropagator, W3CBaggagePropagator } from '@opentelemetry/core';
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
-import { resourceFromAttributes } from '@opentelemetry/resources';
-import { NodeSDK } from '@opentelemetry/sdk-node';
-import { BatchSpanProcessor, NoopSpanProcessor } from '@opentelemetry/sdk-trace-base';
-import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
-
-var otlpExporter = new OTLPTraceExporter();
-var logger = getLogger("instrumentation");
-function createSafeBatchProcessor() {
-  try {
-    return new BatchSpanProcessor(otlpExporter, {
-      scheduledDelayMillis: env.OTEL_BSP_SCHEDULE_DELAY,
-      maxExportBatchSize: env.OTEL_BSP_MAX_EXPORT_BATCH_SIZE
-    });
-  } catch (error) {
-    logger.warn({ error }, "Failed to create batch processor");
-    return new NoopSpanProcessor();
-  }
-}
-var defaultBatchProcessor = createSafeBatchProcessor();
-var defaultResource = resourceFromAttributes({
-  [ATTR_SERVICE_NAME]: "inkeep-agents-run-api"
-});
-var defaultInstrumentations = [
-  getNodeAutoInstrumentations({
-    "@opentelemetry/instrumentation-http": {
-      enabled: true,
-      requestHook: (span, request) => {
-        const url = request?.url ?? request?.path;
-        if (!url) return;
-        const u = new URL(url, "http://localhost");
-        span.updateName(`${request?.method || "UNKNOWN"} ${u.pathname}`);
-      }
-    },
-    "@opentelemetry/instrumentation-undici": {
-      requestHook: (span) => {
-        const method = span.attributes?.["http.request.method"];
-        const host = span.attributes?.["server.address"];
-        const path = span.attributes?.["url.path"];
-        if (method && path)
-          span.updateName(host ? `${method} ${host}${path}` : `${method} ${path}`);
-      }
-    }
-  })
-];
-var defaultSpanProcessors = [
-  new BaggageSpanProcessor(ALLOW_ALL_BAGGAGE_KEYS),
-  defaultBatchProcessor
-];
-var defaultContextManager = new AsyncLocalStorageContextManager();
-var defaultTextMapPropagator = new CompositePropagator({
-  propagators: [new W3CTraceContextPropagator(), new W3CBaggagePropagator()]
-});
-var defaultSDK = new NodeSDK({
-  resource: defaultResource,
-  contextManager: defaultContextManager,
-  textMapPropagator: defaultTextMapPropagator,
-  spanProcessors: defaultSpanProcessors,
-  instrumentations: defaultInstrumentations
-});
-async function flushBatchProcessor() {
-  try {
-    await defaultBatchProcessor.forceFlush();
-  } catch (error) {
-    logger.warn({ error }, "Failed to flush batch processor");
-  }
-}
-
-export { defaultBatchProcessor, defaultContextManager, defaultInstrumentations, defaultResource, defaultSDK, defaultSpanProcessors, defaultTextMapPropagator, flushBatchProcessor };

package/dist/conversations-XPSTWUMK.js

@@ -1 +0,0 @@
-export { createDefaultConversationHistoryConfig, getConversationScopedArtifacts, getFormattedConversationHistory, getFullConversationContext, getScopedHistory, getUserFacingHistory, saveA2AMessageResponse } from './chunk-KCJWSIDZ.js';

package/dist/dbClient-MAHUR4TO.js

@@ -1 +0,0 @@
-export { dbClient_default as default } from './chunk-EVOISBFH.js';

package/dist/json-postprocessor-IGYTSWFB.js

@@ -1,12 +0,0 @@
-// src/utils/json-postprocessor.ts
-function stripJsonCodeBlocks(text) {
-  return text.trim().replace(/^```json\s*/is, "").replace(/^```\s*/s, "").replace(/\s*```$/s, "").replace(/^```json\s*([\s\S]*?)\s*```$/i, "$1").replace(/^```\s*([\s\S]*?)\s*```$/i, "$1").trim();
-}
-function withJsonPostProcessing(config) {
-  return {
-    ...config,
-    experimental_transform: (text) => stripJsonCodeBlocks(text)
-  };
-}
-
-export { stripJsonCodeBlocks, withJsonPostProcessing };

package/dist/logger-3EE6BUSU.js

@@ -1 +0,0 @@
-export { getLogger } from './chunk-A2S7GSHL.js';

package/dist/nodefs-RPE52Q4Z.js

@@ -1,21 +0,0 @@
-import { u, ur, C } from './chunk-JCVMVG3J.js';
-import * as s from 'fs';
-import * as o from 'path';
-
-u();
-var m = class extends ur {
-  constructor(t) {
-    super(t), this.rootDir = o.resolve(t), s.existsSync(o.join(this.rootDir)) || s.mkdirSync(this.rootDir);
-  }
-  async init(t, e) {
-    return this.pg = t, { emscriptenOpts: { ...e, preRun: [...e.preRun || [], (r) => {
-      let c = r.FS.filesystems.NODEFS;
-      r.FS.mkdir(C), r.FS.mount(c, { root: this.rootDir }, C);
-    }] } };
-  }
-  async closeFs() {
-    this.pg.Module.FS.quit();
-  }
-};
-
-export { m as NodeFS };