@inkeep/agents-work-apps 0.0.0-dev-20260204182014 → 0.0.0-dev-20260204210021

package/dist/slack/routes.d.ts

@@ -1,7 +0,0 @@
-import { getChannelAgentConfig, getWorkspaceDefaultAgent } from "./services/events/utils.js";
-import "./services/events/index.js";
-import { getBotTokenForTeam, setBotTokenForTeam } from "./services/workspace-tokens.js";
-import "./routes/oauth.js";
-import { pendingSessionTokens } from "./routes/users.js";
-import app from "./routes/index.js";
-export { app as default, getBotTokenForTeam, getChannelAgentConfig, getWorkspaceDefaultAgent, pendingSessionTokens, setBotTokenForTeam };

package/dist/slack/routes.js

@@ -1,12 +0,0 @@
-import { getBotTokenForTeam, setBotTokenForTeam } from "./services/workspace-tokens.js";
-import { getChannelAgentConfig, getWorkspaceDefaultAgent } from "./services/events/utils.js";
-import "./services/events/index.js";
-import "./routes/oauth.js";
-import { pendingSessionTokens } from "./routes/users.js";
-import routes_default$1 from "./routes/index.js";
-
-//#region src/slack/routes.ts
-var routes_default = routes_default$1;
-
-//#endregion
-export { routes_default as default, getBotTokenForTeam, getChannelAgentConfig, getWorkspaceDefaultAgent, pendingSessionTokens, setBotTokenForTeam };

package/dist/slack/services/agent-resolution.d.ts

@@ -1,49 +0,0 @@
-//#region src/slack/services/agent-resolution.d.ts
-/**
- * Slack Agent Resolution Service
- *
- * Determines which agent to use for a given Slack interaction.
- *
- * For @mentions (bot interactions):
- * - Uses Channel > Workspace defaults (admin-controlled)
- *
- * For /slash commands (user interactions):
- * - User personal default > Channel > Workspace
- * - Users can set their own default via /inkeep settings
- */
-/** Configuration for a resolved agent */
-interface ResolvedAgentConfig {
-  projectId: string;
-  agentId: string;
-  agentName?: string;
-  source: 'channel' | 'workspace' | 'user' | 'none';
-}
-interface AgentResolutionParams {
-  tenantId: string;
-  teamId: string;
-  channelId?: string;
-  userId?: string;
-}
-/**
- * Resolve the effective agent configuration for a Slack slash command.
- * Priority: User personal default > Channel override > Workspace default
- *
- * @param params - Resolution parameters including tenant, team, channel, and user IDs
- * @returns The resolved agent configuration, or null if no agent is configured
- */
-declare function resolveEffectiveAgent(params: AgentResolutionParams): Promise<ResolvedAgentConfig | null>;
-/**
- * Get all agent configuration sources for debugging and display purposes.
- * Returns each level of configuration and the effective result.
- *
- * @param params - Resolution parameters
- * @returns Object containing channel, workspace, user configs, and the effective choice
- */
-declare function getAgentConfigSources(params: AgentResolutionParams): Promise<{
-  channelConfig: ResolvedAgentConfig | null;
-  workspaceConfig: ResolvedAgentConfig | null;
-  userConfig: ResolvedAgentConfig | null;
-  effective: ResolvedAgentConfig | null;
-}>;
-//#endregion
-export { AgentResolutionParams, ResolvedAgentConfig, getAgentConfigSources, resolveEffectiveAgent };

package/dist/slack/services/agent-resolution.js

@@ -1,135 +0,0 @@
-import { getLogger } from "../../logger.js";
-import runDbClient_default from "../../db/runDbClient.js";
-import { getWorkspaceDefaultAgentFromNango } from "./nango.js";
-import { findWorkAppSlackChannelAgentConfig, findWorkAppSlackUserSettings } from "@inkeep/agents-core";
-
-//#region src/slack/services/agent-resolution.ts
-/**
-* Slack Agent Resolution Service
-*
-* Determines which agent to use for a given Slack interaction.
-*
-* For @mentions (bot interactions):
-* - Uses Channel > Workspace defaults (admin-controlled)
-*
-* For /slash commands (user interactions):
-* - User personal default > Channel > Workspace
-* - Users can set their own default via /inkeep settings
-*/
-const logger = getLogger("slack-agent-resolution");
-/**
-* Resolve the effective agent configuration for a Slack slash command.
-* Priority: User personal default > Channel override > Workspace default
-*
-* @param params - Resolution parameters including tenant, team, channel, and user IDs
-* @returns The resolved agent configuration, or null if no agent is configured
-*/
-async function resolveEffectiveAgent(params) {
-	const { tenantId, teamId, channelId, userId } = params;
-	logger.debug({
-		tenantId,
-		teamId,
-		channelId,
-		userId
-	}, "Resolving effective agent");
-	if (userId) {
-		const userSettings = await findWorkAppSlackUserSettings(runDbClient_default)(tenantId, teamId, userId);
-		if (userSettings?.defaultAgentId && userSettings.defaultProjectId) {
-			logger.info({
-				userId,
-				agentId: userSettings.defaultAgentId,
-				source: "user"
-			}, "Resolved agent from user settings");
-			return {
-				projectId: userSettings.defaultProjectId,
-				agentId: userSettings.defaultAgentId,
-				agentName: userSettings.defaultAgentName || void 0,
-				source: "user"
-			};
-		}
-	}
-	if (channelId) {
-		const channelConfig = await findWorkAppSlackChannelAgentConfig(runDbClient_default)(tenantId, teamId, channelId);
-		if (channelConfig?.enabled) {
-			logger.info({
-				channelId,
-				agentId: channelConfig.agentId,
-				source: "channel"
-			}, "Resolved agent from channel config");
-			return {
-				projectId: channelConfig.projectId,
-				agentId: channelConfig.agentId,
-				agentName: channelConfig.agentName || void 0,
-				source: "channel"
-			};
-		}
-	}
-	const workspaceConfig = await getWorkspaceDefaultAgentFromNango(teamId);
-	if (workspaceConfig?.agentId && workspaceConfig.projectId) {
-		logger.info({
-			teamId,
-			agentId: workspaceConfig.agentId,
-			source: "workspace"
-		}, "Resolved agent from workspace config");
-		return {
-			projectId: workspaceConfig.projectId,
-			agentId: workspaceConfig.agentId,
-			agentName: workspaceConfig.agentName,
-			source: "workspace"
-		};
-	}
-	logger.debug({
-		tenantId,
-		teamId,
-		channelId,
-		userId
-	}, "No agent configuration found");
-	return null;
-}
-/**
-* Get all agent configuration sources for debugging and display purposes.
-* Returns each level of configuration and the effective result.
-*
-* @param params - Resolution parameters
-* @returns Object containing channel, workspace, user configs, and the effective choice
-*/
-async function getAgentConfigSources(params) {
-	const { tenantId, teamId, channelId, userId } = params;
-	let channelConfig = null;
-	let workspaceConfig = null;
-	let userConfig = null;
-	if (channelId) {
-		const config = await findWorkAppSlackChannelAgentConfig(runDbClient_default)(tenantId, teamId, channelId);
-		if (config?.enabled) channelConfig = {
-			projectId: config.projectId,
-			agentId: config.agentId,
-			agentName: config.agentName || void 0,
-			source: "channel"
-		};
-	}
-	const wsConfig = await getWorkspaceDefaultAgentFromNango(teamId);
-	if (wsConfig?.agentId && wsConfig.projectId) workspaceConfig = {
-		projectId: wsConfig.projectId,
-		agentId: wsConfig.agentId,
-		agentName: wsConfig.agentName,
-		source: "workspace"
-	};
-	if (userId) {
-		const settings = await findWorkAppSlackUserSettings(runDbClient_default)(tenantId, teamId, userId);
-		if (settings?.defaultAgentId && settings.defaultProjectId) userConfig = {
-			projectId: settings.defaultProjectId,
-			agentId: settings.defaultAgentId,
-			agentName: settings.defaultAgentName || void 0,
-			source: "user"
-		};
-	}
-	return {
-		channelConfig,
-		workspaceConfig,
-		userConfig,
-		effective: userConfig || channelConfig || workspaceConfig
-	};
-}
-
-//#endregion
-export { getAgentConfigSources, resolveEffectiveAgent };

package/dist/slack/services/api-client.d.ts

@@ -1,161 +0,0 @@
-//#region src/slack/services/api-client.d.ts
-/**
- * Slack API Client
- *
- * A reusable client for making authenticated API calls from Slack commands.
- * Uses the user's session token stored in Nango to authenticate requests.
- *
- * Usage:
- * ```typescript
- * const client = new SlackApiClient({
- *   sessionToken: connection.inkeepSessionToken,
- *   tenantId: connection.tenantId,
- * });
- *
- * const projects = await client.listProjects();
- * const agents = await client.listAgents(projectId);
- * ```
- */
-declare class SlackApiError extends Error {
-  readonly statusCode: number;
-  readonly responseBody?: string | undefined;
-  constructor(message: string, statusCode: number, responseBody?: string | undefined);
-  get isUnauthorized(): boolean;
-  get isForbidden(): boolean;
-  get isNotFound(): boolean;
-}
-interface SlackApiClientConfig {
-  sessionToken: string;
-  tenantId: string;
-  apiUrl?: string;
-}
-interface PaginatedResponse<T> {
-  data: T[];
-  pagination: {
-    page: number;
-    limit: number;
-    total: number;
-    pages: number;
-  };
-}
-interface Project {
-  id: string;
-  name: string | null;
-  description: string | null;
-  tenantId: string;
-  createdAt: string;
-  updatedAt: string;
-}
-interface Agent {
-  id: string;
-  name: string | null;
-  description: string | null;
-  projectId: string;
-  createdAt: string;
-  updatedAt: string;
-}
-interface ApiKey {
-  id: string;
-  name: string;
-  agentId: string;
-  keyPrefix: string;
-  expiresAt: string | null;
-  createdAt: string;
-}
-interface ApiKeyCreationResponse {
-  apiKey: ApiKey;
-  key: string;
-}
-interface AgentWithProject extends Agent {
-  projectName: string | null;
-}
-interface ChatMessage {
-  role: 'user' | 'assistant' | 'system';
-  content: string;
-}
-interface ChatCompletionResponse {
-  id: string;
-  object: string;
-  created: number;
-  model: string;
-  choices: Array<{
-    index: number;
-    message: {
-      role: string;
-      content: string;
-    };
-    finish_reason: string;
-  }>;
-}
-declare class SlackApiClient {
-  private readonly sessionToken;
-  private readonly tenantId;
-  private readonly apiUrl;
-  constructor(config: SlackApiClientConfig);
-  private get headers();
-  private buildUrl;
-  private request;
-  listProjects(options?: {
-    page?: number;
-    limit?: number;
-  }): Promise<PaginatedResponse<Project>>;
-  getProject(projectId: string): Promise<{
-    data: Project;
-  }>;
-  listAgents(projectId: string, options?: {
-    page?: number;
-    limit?: number;
-  }): Promise<PaginatedResponse<Agent>>;
-  getAgent(projectId: string, agentId: string): Promise<{
-    data: Agent;
-  }>;
-  listAllAgents(): Promise<AgentWithProject[]>;
-  findAgentByName(agentName: string): Promise<AgentWithProject | null>;
-  /**
-   * Trigger an agent and get a response.
-   * Uses the session token for auth via the sub-agent chat completions endpoint.
-   */
-  triggerAgent(params: {
-    projectId: string;
-    agentId: string;
-    subAgentId: string;
-    question: string;
-    conversationId?: string;
-  }): Promise<{
-    content: string;
-    conversationId?: string;
-  }>;
-  listApiKeys(projectId: string, agentId?: string): Promise<PaginatedResponse<ApiKey>>;
-  createApiKey(projectId: string, agentId: string, name: string): Promise<{
-    data: ApiKeyCreationResponse;
-  }>;
-  deleteApiKey(projectId: string, apiKeyId: string): Promise<void>;
-  getOrCreateAgentApiKey(projectId: string, agentId: string): Promise<string>;
-  getTenantId(): string;
-}
-/**
- * Factory function to create a SlackApiClient from a Nango connection
- */
-declare function createSlackApiClient(connection: {
-  inkeepSessionToken?: string;
-  inkeepSessionExpiresAt?: string;
-  tenantId?: string;
-}): SlackApiClient;
-/**
- * Send a deferred response to Slack via response_url
- *
- * Slack slash commands have a 3-second timeout. For long-running operations
- * like agent execution, we need to:
- * 1. Respond immediately with a "thinking" message
- * 2. Process the request asynchronously
- * 3. Send the actual response via response_url
- */
-declare function sendDeferredResponse(responseUrl: string, message: {
-  response_type?: 'ephemeral' | 'in_channel';
-  text?: string;
-  blocks?: unknown[];
-  replace_original?: boolean;
-  delete_original?: boolean;
-}): Promise<void>;
-//#endregion
-export { Agent, AgentWithProject, ApiKey, ApiKeyCreationResponse, ChatCompletionResponse, ChatMessage, PaginatedResponse, Project, SlackApiClient, SlackApiClientConfig, SlackApiError, createSlackApiClient, sendDeferredResponse };

package/dist/slack/services/api-client.js

@@ -1,248 +0,0 @@
-import { env } from "../../env.js";
-import { getLogger } from "../../logger.js";
-
-//#region src/slack/services/api-client.ts
-/**
-* Slack API Client
-*
-* A reusable client for making authenticated API calls from Slack commands.
-* Uses the user's session token stored in Nango to authenticate requests.
-*
-* Usage:
-* ```typescript
-* const client = new SlackApiClient({
-*   sessionToken: connection.inkeepSessionToken,
-*   tenantId: connection.tenantId,
-* });
-*
-* const projects = await client.listProjects();
-* const agents = await client.listAgents(projectId);
-* ```
-*/
-const logger = getLogger("slack-api-client");
-var SlackApiError = class extends Error {
-	constructor(message, statusCode, responseBody) {
-		super(message);
-		this.statusCode = statusCode;
-		this.responseBody = responseBody;
-		this.name = "SlackApiError";
-	}
-	get isUnauthorized() {
-		return this.statusCode === 401;
-	}
-	get isForbidden() {
-		return this.statusCode === 403;
-	}
-	get isNotFound() {
-		return this.statusCode === 404;
-	}
-};
-var SlackApiClient = class {
-	sessionToken;
-	tenantId;
-	apiUrl;
-	constructor(config) {
-		this.sessionToken = config.sessionToken;
-		this.tenantId = config.tenantId;
-		this.apiUrl = config.apiUrl || env.INKEEP_AGENTS_API_URL || "http://localhost:3002";
-	}
-	get headers() {
-		return {
-			"Content-Type": "application/json",
-			Authorization: `Bearer ${this.sessionToken}`
-		};
-	}
-	buildUrl(path, params) {
-		const normalizedBase = this.apiUrl.replace(/\/$/, "");
-		const url = new URL(`${normalizedBase}${path}`);
-		if (params) {
-			for (const [key, value] of Object.entries(params)) if (value !== void 0) url.searchParams.set(key, String(value));
-		}
-		return url.toString();
-	}
-	async request(method, path, options) {
-		const url = this.buildUrl(path, options?.params);
-		logger.debug({
-			method,
-			path,
-			tenantId: this.tenantId
-		}, "Making API request");
-		const response = await fetch(url, {
-			method,
-			headers: this.headers,
-			body: options?.body ? JSON.stringify(options.body) : void 0
-		});
-		if (!response.ok) {
-			const errorBody = await response.text().catch(() => "Unknown error");
-			logger.error({
-				status: response.status,
-				path,
-				tenantId: this.tenantId
-			}, "API request failed");
-			if (response.status === 401) throw new SlackApiError("Session expired. Please re-link your account from the dashboard.", response.status, errorBody);
-			throw new SlackApiError(`API error: ${response.status} ${response.statusText}`, response.status, errorBody);
-		}
-		if (response.status === 204 || options?.expectNoContent) return;
-		return response.json();
-	}
-	async listProjects(options) {
-		return this.request("GET", `/manage/tenants/${this.tenantId}/projects`, { params: {
-			page: options?.page || 1,
-			limit: options?.limit || 100
-		} });
-	}
-	async getProject(projectId) {
-		return this.request("GET", `/manage/tenants/${this.tenantId}/projects/${projectId}`);
-	}
-	async listAgents(projectId, options) {
-		return this.request("GET", `/manage/tenants/${this.tenantId}/projects/${projectId}/agents`, { params: {
-			page: options?.page || 1,
-			limit: options?.limit || 100
-		} });
-	}
-	async getAgent(projectId, agentId) {
-		return this.request("GET", `/manage/tenants/${this.tenantId}/projects/${projectId}/agents/${agentId}`);
-	}
-	async listAllAgents() {
-		const projectsResult = await this.listProjects({ limit: 100 });
-		return (await Promise.all(projectsResult.data.map(async (project) => {
-			try {
-				return (await this.listAgents(project.id, { limit: 100 })).data.map((agent) => ({
-					...agent,
-					projectName: project.name
-				}));
-			} catch (error) {
-				logger.warn({
-					projectId: project.id,
-					error
-				}, "Failed to list agents for project");
-				return [];
-			}
-		}))).flat();
-	}
-	async findAgentByName(agentName) {
-		const agents = await this.listAllAgents();
-		const normalizedSearch = agentName.toLowerCase().trim();
-		const exactMatch = agents.find((a) => a.name?.toLowerCase() === normalizedSearch || a.id.toLowerCase() === normalizedSearch);
-		if (exactMatch) return exactMatch;
-		return agents.find((a) => a.name?.toLowerCase().includes(normalizedSearch) || a.id.toLowerCase().includes(normalizedSearch)) || null;
-	}
-	/**
-	* Trigger an agent and get a response.
-	* Uses the session token for auth via the sub-agent chat completions endpoint.
-	*/
-	async triggerAgent(params) {
-		const { projectId, agentId, subAgentId, question, conversationId } = params;
-		logger.info({
-			projectId,
-			agentId,
-			subAgentId,
-			tenantId: this.tenantId
-		}, "Triggering agent from Slack");
-		const url = this.buildUrl(`/run/tenants/${this.tenantId}/projects/${projectId}/agents/${agentId}/sub-agents/${subAgentId}/chat/completions`);
-		const response = await fetch(url, {
-			method: "POST",
-			headers: this.headers,
-			body: JSON.stringify({
-				model: subAgentId,
-				messages: [{
-					role: "user",
-					content: question
-				}],
-				stream: false,
-				...conversationId ? { conversationId } : {}
-			})
-		});
-		if (!response.ok) {
-			const errorBody = await response.text().catch(() => "Unknown error");
-			logger.error({
-				status: response.status,
-				projectId,
-				agentId,
-				subAgentId
-			}, "Agent trigger failed");
-			if (response.status === 401) throw new SlackApiError("Session expired. Please re-link your account from the dashboard.", response.status, errorBody);
-			throw new SlackApiError(`Failed to trigger agent: ${response.status}`, response.status, errorBody);
-		}
-		const result = await response.json();
-		return {
-			content: result.choices?.[0]?.message?.content || result.content || "No response from agent",
-			conversationId: result.conversationId
-		};
-	}
-	async listApiKeys(projectId, agentId) {
-		const params = { limit: 100 };
-		if (agentId) params.agentId = agentId;
-		return this.request("GET", `/manage/tenants/${this.tenantId}/projects/${projectId}/api-keys`, { params });
-	}
-	async createApiKey(projectId, agentId, name) {
-		return this.request("POST", `/manage/tenants/${this.tenantId}/projects/${projectId}/api-keys`, { body: {
-			agentId,
-			name
-		} });
-	}
-	async deleteApiKey(projectId, apiKeyId) {
-		await this.request("DELETE", `/manage/tenants/${this.tenantId}/projects/${projectId}/api-keys/${apiKeyId}`, { expectNoContent: true });
-	}
-	async getOrCreateAgentApiKey(projectId, agentId) {
-		const slackKey = (await this.listApiKeys(projectId, agentId)).data.find((k) => k.name === "slack-integration");
-		if (slackKey) {
-			logger.debug({
-				apiKeyId: slackKey.id,
-				agentId
-			}, "Deleting existing slack-integration key to create fresh one");
-			await this.deleteApiKey(projectId, slackKey.id);
-		}
-		return (await this.createApiKey(projectId, agentId, "slack-integration")).data.key;
-	}
-	getTenantId() {
-		return this.tenantId;
-	}
-};
-/**
-* Factory function to create a SlackApiClient from a Nango connection
-*/
-function createSlackApiClient(connection) {
-	if (!connection.inkeepSessionToken) throw new SlackApiError("Session expired. Please re-link your account from the dashboard.", 401);
-	if (connection.inkeepSessionExpiresAt) {
-		if (new Date(connection.inkeepSessionExpiresAt) < /* @__PURE__ */ new Date()) throw new SlackApiError("Session expired. Please re-link your account from the dashboard.", 401);
-	}
-	return new SlackApiClient({
-		sessionToken: connection.inkeepSessionToken,
-		tenantId: connection.tenantId || "default"
-	});
-}
-/**
-* Send a deferred response to Slack via response_url
-*
-* Slack slash commands have a 3-second timeout. For long-running operations
-* like agent execution, we need to:
-* 1. Respond immediately with a "thinking" message
-* 2. Process the request asynchronously
-* 3. Send the actual response via response_url
-*/
-async function sendDeferredResponse(responseUrl, message) {
-	try {
-		const response = await fetch(responseUrl, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({
-				response_type: message.response_type || "ephemeral",
-				replace_original: message.replace_original ?? true,
-				...message
-			})
-		});
-		if (!response.ok) {
-			const errorBody = await response.text().catch(() => "Unknown error");
-			logger.error({
-				status: response.status,
-				errorBody
-			}, "Failed to send deferred Slack response");
-		} else logger.debug({}, "Deferred Slack response sent successfully");
-	} catch (error) {
-		logger.error({ error }, "Error sending deferred Slack response");
-	}
-}
-
-//#endregion
-export { SlackApiClient, SlackApiError, createSlackApiClient, sendDeferredResponse };

package/dist/slack/services/auth/index.d.ts

@@ -1,61 +0,0 @@
-import { SlackAccessTokenPayload } from "@inkeep/agents-core";
-
-//#region src/slack/services/auth/index.d.ts
-
-interface SlackUserContext {
-  slackUserId: string;
-  slackTeamId: string;
-  slackEnterpriseId?: string;
-}
-interface SlackJwtResult {
-  token: string;
-  inkeepUserId: string;
-  tenantId: string;
-}
-declare class SlackJwtAuthError extends Error {
-  readonly code: 'NOT_LINKED' | 'TOKEN_EXPIRED' | 'TOKEN_INVALID' | 'EXECUTION_FAILED';
-  constructor(message: string, code: 'NOT_LINKED' | 'TOKEN_EXPIRED' | 'TOKEN_INVALID' | 'EXECUTION_FAILED');
-}
-/**
- * Get a JWT token for a Slack user to call Inkeep APIs.
- *
- * Looks up the user's linked Inkeep account and generates a short-lived JWT.
- */
-declare function getSlackUserJwt(context: SlackUserContext, tenantId: string): Promise<SlackJwtResult>;
-/**
- * Verify a Slack JWT token and extract the payload.
- */
-declare function verifySlackJwt(token: string): Promise<SlackAccessTokenPayload>;
-interface ChatCompletionOptions {
-  conversationId?: string;
-  stream?: boolean;
-}
-interface ChatCompletionResult {
-  content: string;
-  conversationId?: string;
-}
-/**
- * Execute an agent using Slack JWT authentication.
- *
- * This is the unified way to call agents from Slack - uses JWT, not API keys.
- */
-declare function executeAgentWithSlackJwt(params: {
-  jwt: string;
-  projectId: string;
-  agentId: string;
-  message: string;
-  options?: ChatCompletionOptions;
-}): Promise<ChatCompletionResult>;
-/**
- * Stream agent response with Slack JWT authentication.
- *
- * Returns a readable stream of SSE events for real-time streaming to Slack.
- */
-declare function streamAgentWithSlackJwt(params: {
-  jwt: string;
-  projectId: string;
-  agentId: string;
-  message: string;
-}): Promise<Response>;
-//#endregion
-export { ChatCompletionOptions, ChatCompletionResult, type SlackAccessTokenPayload, SlackJwtAuthError, SlackJwtResult, SlackUserContext, executeAgentWithSlackJwt, getSlackUserJwt, streamAgentWithSlackJwt, verifySlackJwt };