@inkeep/agents-run-api 0.0.0-dev-20250910233133 → 0.0.0-dev-20250910233441

package/dist/chunk-3COYP2VE.js

@@ -0,0 +1,70 @@
+import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+import { BaggageSpanProcessor, ALLOW_ALL_BAGGAGE_KEYS } from '@opentelemetry/baggage-span-processor';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-proto';
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-node';
+
+// src/instrumentation.ts
+var otlpUrl = process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:14318/v1/traces";
+var otlpExporter = new OTLPTraceExporter({ url: otlpUrl });
+var FanOutSpanProcessor = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  onStart(span, parent) {
+    this.inner.forEach((p) => p.onStart(span, parent));
+  }
+  onEnd(span) {
+    this.inner.forEach((p) => p.onEnd(span));
+  }
+  forceFlush() {
+    return Promise.all(this.inner.map((p) => p.forceFlush?.())).then(() => {
+    });
+  }
+  shutdown() {
+    return Promise.all(this.inner.map((p) => p.shutdown?.())).then(() => {
+    });
+  }
+};
+var spanProcessor = new FanOutSpanProcessor([
+  new BaggageSpanProcessor(ALLOW_ALL_BAGGAGE_KEYS),
+  new BatchSpanProcessor(otlpExporter, {
+    maxExportBatchSize: 1,
+    // Send immediately (vs 512)
+    scheduledDelayMillis: 100,
+    // 100ms delay (vs 5000ms)
+    exportTimeoutMillis: 5e3,
+    // 5s timeout (vs 30s)
+    maxQueueSize: 512
+    // Smaller queue
+  })
+]);
+var sdk = new NodeSDK({
+  serviceName: "inkeep-chat",
+  spanProcessor,
+  instrumentations: [
+    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}`);
+        }
+      }
+    })
+  ]
+});
+sdk.start();
+
+export { sdk, spanProcessor };

package/dist/chunk-JIWNRFDU.js

@@ -0,0 +1,236 @@
+import { createDatabaseClient, createMessage, getConversationHistory } from '@inkeep/agents-core';
+import { nanoid } from 'nanoid';
+import fs from 'fs';
+import path from 'path';
+import * as dotenv from 'dotenv';
+import { z } from 'zod';
+
+// src/data/conversations.ts
+dotenv.config({ quiet: true });
+z.enum(["development", "production"]).default("development");
+var environmentSchema = z.enum(["development", "pentest", "production", "test"]);
+var criticalEnv = z.object({
+  ENVIRONMENT: environmentSchema
+}).parse(process.env);
+var loadEnvFile = () => {
+  const envPath = path.resolve(process.cwd(), `.env.${criticalEnv.ENVIRONMENT}.nonsecret`);
+  if (fs.existsSync(envPath)) {
+    const envConfig = dotenv.parse(fs.readFileSync(envPath));
+    for (const k in envConfig) {
+      if (!(k in process.env)) {
+        process.env[k] = envConfig[k];
+      }
+    }
+  }
+};
+loadEnvFile();
+var envSchema = z.object({
+  NODE_ENV: z.enum(["development", "production", "test"]).optional(),
+  ENVIRONMENT: z.enum(["development", "production", "pentest", "test"]).optional().default("development"),
+  DB_FILE_NAME: z.string().default("file:../local.db"),
+  PORT: z.coerce.number().optional().default(3003),
+  AGENT_BASE_URL: z.string().optional(),
+  LOG_LEVEL: z.enum(["trace", "debug", "info", "warn", "error"]).optional().default("debug"),
+  NANGO_SECRET_KEY: z.string().optional(),
+  OPENAI_API_KEY: z.string().optional(),
+  ANTHROPIC_API_KEY: z.string(),
+  INKEEP_AGENTS_RUN_BYPASS_SECRET: z.string().optional(),
+  OTEL_TRACES_FORCE_FLUSH_ENABLED: z.stringbool().optional()
+});
+var parseEnv = () => {
+  try {
+    const parsedEnv = envSchema.parse(process.env);
+    if (!parsedEnv.AGENT_BASE_URL) {
+      parsedEnv.AGENT_BASE_URL = `http://localhost:${parsedEnv.PORT}`;
+    }
+    return parsedEnv;
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const missingVars = error.issues.map((issue) => issue.path.join("."));
+      throw new Error(
+        `\u274C Invalid environment variables: ${missingVars.join(", ")}
+${error.message}`
+      );
+    }
+    throw error;
+  }
+};
+var env = parseEnv();
+
+// src/data/db/dbClient.ts
+var getDbUrl = () => {
+  if (env.ENVIRONMENT === "test") {
+    return ":memory:";
+  }
+  return env.DB_FILE_NAME;
+};
+var dbClient = createDatabaseClient({ url: getDbUrl() });
+var dbClient_default = dbClient;
+
+// src/data/conversations.ts
+function createDefaultConversationHistoryConfig(mode = "full") {
+  return {
+    mode,
+    limit: 50,
+    includeInternal: true,
+    messageTypes: ["chat"],
+    maxOutputTokens: 4e3
+  };
+}
+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: nanoid(),
+    tenantId: params.tenantId,
+    projectId: params.projectId,
+    conversationId: params.conversationId,
+    role: "agent",
+    content: {
+      text: messageText
+    },
+    visibility: params.visibility,
+    messageType: params.messageType,
+    fromAgentId: params.fromAgentId,
+    toAgentId: params.toAgentId,
+    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.agentId && !filters.taskId) {
+      return messages;
+    }
+    const relevantMessages = messages.filter((msg) => {
+      if (msg.role === "user") return true;
+      let matchesAgent = true;
+      let matchesTask = true;
+      if (filters.agentId) {
+        matchesAgent = msg.role === "agent" && msg.visibility === "user-facing" || msg.toAgentId === filters.agentId || msg.fromAgentId === filters.agentId;
+      }
+      if (filters.taskId) {
+        matchesTask = msg.taskId === filters.taskId || msg.a2aTaskId === filters.taskId;
+      }
+      if (filters.agentId && filters.taskId) {
+        return matchesAgent && matchesTask;
+      }
+      if (filters.agentId) {
+        return matchesAgent;
+      }
+      if (filters.taskId) {
+        return matchesTask;
+      }
+      return false;
+    });
+    return relevantMessages;
+  } catch (error) {
+    console.error("Failed to fetch scoped messages:", error);
+    return [];
+  }
+}
+async function getUserFacingHistory(tenantId, projectId, conversationId, limit = 50) {
+  return await getConversationHistory(dbClient_default)({
+    scopes: { tenantId, projectId },
+    conversationId,
+    options: {
+      limit,
+      includeInternal: false,
+      messageTypes: ["chat"]
+    }
+  });
+}
+async function getFullConversationContext(tenantId, projectId, conversationId, maxTokens) {
+  return await getConversationHistory(dbClient_default)({
+    scopes: { tenantId, projectId },
+    conversationId,
+    options: {
+      limit: 100,
+      includeInternal: true,
+      maxOutputTokens: maxTokens
+    }
+  });
+}
+async function getFormattedConversationHistory({
+  tenantId,
+  projectId,
+  conversationId,
+  currentMessage,
+  options,
+  filters
+}) {
+  const historyOptions = options ?? { includeInternal: true };
+  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 fromAgent = msg.fromAgentId || msg.fromExternalAgentId || "unknown";
+      const toAgent = msg.toAgentId || msg.toExternalAgentId || "unknown";
+      roleLabel = `${fromAgent} to ${toAgent}`;
+    } else if (msg.role === "agent" && msg.messageType === "chat") {
+      const fromAgent = msg.fromAgentId || "unknown";
+      roleLabel = `${fromAgent} to User`;
+    } else {
+      roleLabel = msg.role || "system";
+    }
+    return `${roleLabel}: """${msg.content.text}"""`;
+  }).join("\n");
+  return `<conversation_history>
+${formattedHistory}
+</conversation_history>
+`;
+}
+
+export { createDefaultConversationHistoryConfig, dbClient_default, env, getFormattedConversationHistory, getFullConversationContext, getScopedHistory, getUserFacingHistory, saveA2AMessageResponse };

package/dist/chunk-PKBMQBKP.js

@@ -0,0 +1,5 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+export { __publicField };

package/dist/conversations-YTJWHN67.js

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