mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-01-30 06:15:18 +01:00
🛸 feat: Remote Agent Access with External API Support (#11503)
* 🪪 feat: Microsoft Graph Access Token Placeholder for MCP Servers (#10867) * feat: MCP Graph Token env var * Addressing copilot remarks * Addressed Copilot review remarks * Fixed graphtokenservice mock in MCP test suite * fix: remove unnecessary type check and cast in resolveGraphTokensInRecord * ci: add Graph Token integration tests in MCPManager * refactor: update user type definitions to use Partial<IUser> in multiple functions * test: enhance MCP tests for graph token processing and user placeholder resolution - Added comprehensive tests to validate the interaction between preProcessGraphTokens and processMCPEnv. - Ensured correct resolution of graph tokens and user placeholders in various configurations. - Mocked OIDC utilities to facilitate testing of token extraction and validation. - Verified that original options remain unchanged after processing. * chore: import order * chore: imports --------- Co-authored-by: Danny Avila <danny@librechat.ai> * WIP: OpenAI-compatible API for LibreChat agents - Added OpenAIChatCompletionController for handling chat completions. - Introduced ListModelsController and GetModelController for listing and retrieving agent details. - Created routes for OpenAI API endpoints, including /v1/chat/completions and /v1/models. - Developed event handlers for streaming responses in OpenAI format. - Implemented request validation and error handling for API interactions. - Integrated content aggregation and response formatting to align with OpenAI specifications. This commit establishes a foundational API for interacting with LibreChat agents in a manner compatible with OpenAI's chat completion interface. * refactor: OpenAI-spec content aggregation for improved performance and clarity * fix: OpenAI chat completion controller with safe user handling for correct tool loading * refactor: Remove conversation ID from OpenAI response context and related handlers * refactor: OpenAI chat completion handling with streaming support - Introduced a lightweight tracker for streaming responses, allowing for efficient tracking of emitted content and usage metadata. - Updated the OpenAIChatCompletionController to utilize the new tracker, improving the handling of streaming and non-streaming responses. - Refactored event handlers to accommodate the new streaming logic, ensuring proper management of tool calls and content aggregation. - Adjusted response handling to streamline error reporting during streaming sessions. * WIP: Open Responses API with core service, types, and handlers - Added Open Responses API module with comprehensive types and enums. - Implemented core service for processing requests, including validation and input conversion. - Developed event handlers for streaming responses and non-streaming aggregation. - Established response building logic and error handling mechanisms. - Created detailed types for input and output content, ensuring compliance with Open Responses specification. * feat: Implement response storage and retrieval in Open Responses API - Added functionality to save user input messages and assistant responses to the database when the `store` flag is set to true. - Introduced a new endpoint to retrieve stored responses by ID, allowing users to access previous interactions. - Enhanced the response creation process to include database operations for conversation and message storage. - Implemented tests to validate the storage and retrieval of responses, ensuring correct behavior for both existing and non-existent response IDs. * refactor: Open Responses API with additional token tracking and validation - Added support for tracking cached tokens in response usage, improving token management. - Updated response structure to include new properties for top log probabilities and detailed usage metrics. - Enhanced tests to validate the presence and types of new properties in API responses, ensuring compliance with updated specifications. - Refactored response handling to accommodate new fields and improve overall clarity and performance. * refactor: Update reasoning event handlers and types for consistency - Renamed reasoning text events to simplify naming conventions, changing `emitReasoningTextDelta` to `emitReasoningDelta` and `emitReasoningTextDone` to `emitReasoningDone`. - Updated event types in the API to reflect the new naming, ensuring consistency across the codebase. - Added `logprobs` property to output events for enhanced tracking of log probabilities. * feat: Add validation for streaming events in Open Responses API tests * feat: Implement response.created event in Open Responses API - Added emitResponseCreated function to emit the response.created event as the first event in the streaming sequence, adhering to the Open Responses specification. - Updated createResponse function to emit response.created followed by response.in_progress. - Enhanced tests to validate the order of emitted events, ensuring response.created is triggered before response.in_progress. * feat: Responses API with attachment event handling - Introduced `createResponsesToolEndCallback` to handle attachment events in the Responses API, emitting `librechat:attachment` events as per the Open Responses extension specification. - Updated the `createResponse` function to utilize the new callback for processing tool outputs and emitting attachments during streaming. - Added helper functions for writing attachment events and defined types for attachment data, ensuring compatibility with the Open Responses protocol. - Enhanced tests to validate the integration of attachment events within the Responses API workflow. * WIP: remote agent auth * fix: Improve loading state handling in AgentApiKeys component - Updated the rendering logic to conditionally display loading spinner and API keys based on the loading state. - Removed unnecessary imports and streamlined the component for better readability. * refactor: Update API key access handling in routes - Replaced `checkAccess` with `generateCheckAccess` for improved access control. - Consolidated access checks into a single `checkApiKeyAccess` function, enhancing code readability and maintainability. - Streamlined route definitions for creating, listing, retrieving, and deleting API keys. * fix: Add permission handling for REMOTE_AGENT resource type * feat: Enhance permission handling for REMOTE_AGENT resources - Updated the deleteAgent and deleteUserAgents functions to handle permissions for both AGENT and REMOTE_AGENT resource types. - Introduced new functions to enrich REMOTE_AGENT principals and backfill permissions for AGENT owners. - Modified createAgentHandler and duplicateAgentHandler to grant permissions for REMOTE_AGENT alongside AGENT. - Added utility functions for retrieving effective permissions for REMOTE_AGENT resources, ensuring consistent access control across the application. * refactor: Rename and update roles for remote agent access - Changed role name from API User to Editor in translation files for clarity. - Updated default editor role ID from REMOTE_AGENT_USER to REMOTE_AGENT_EDITOR in resource configurations. - Adjusted role localization to reflect the new Editor role. - Modified access permissions to align with the updated role definitions across the application. * feat: Introduce remote agent permissions and update access handling - Added support for REMOTE_AGENTS in permission schemas, including use, create, share, and share_public permissions. - Updated the interface configuration to include remote agent settings. - Modified middleware and API key access checks to align with the new remote agent permission structure. - Enhanced role defaults to incorporate remote agent permissions, ensuring consistent access control across the application. * refactor: Update AgentApiKeys component and permissions handling - Refactored the AgentApiKeys component to improve structure and readability, including the introduction of ApiKeysContent for better separation of concerns. - Updated CreateKeyDialog to accept an onKeyCreated callback, enhancing its functionality. - Adjusted permission checks in Data component to use REMOTE_AGENTS and USE permissions, aligning with recent permission schema changes. - Enhanced loading state handling and dialog management for a smoother user experience. * refactor: Update remote agent access checks in API routes - Replaced existing access checks with `generateCheckAccess` for remote agents in the API keys and agents routes. - Introduced specific permission checks for creating, listing, retrieving, and deleting API keys, enhancing access control. - Improved code structure by consolidating permission handling for remote agents across multiple routes. * fix: Correct query parameters in ApiKeysContent component - Updated the useGetAgentApiKeysQuery call to include an object for the enabled parameter, ensuring proper functionality when the component is open. - This change improves the handling of API key retrieval based on the component's open state. * feat: Implement remote agents permissions and update API routes - Added new API route for updating remote agents permissions, enhancing role management capabilities. - Introduced remote agents permissions handling in the AgentApiKeys component, including a dedicated settings dialog. - Updated localization files to include new remote agents permission labels for better user experience. - Refactored data provider to support remote agents permissions updates, ensuring consistent access control across the application. * feat: Add remote agents permissions to role schema and interface - Introduced new permissions for REMOTE_AGENTS in the role schema, including USE, CREATE, SHARE, and SHARE_PUBLIC. - Updated the IRole interface to reflect the new remote agents permissions structure, enhancing role management capabilities. * feat: Add remote agents settings button to API keys dialog * feat: Update AgentFooter to include remote agent sharing permissions - Refactored access checks to incorporate permissions for sharing remote agents. - Enhanced conditional rendering logic to allow sharing by users with remote agent permissions. - Improved loading state handling for remote agent permissions, ensuring a smoother user experience. * refactor: Update API key creation access check and localization strings - Replaced the access check for creating API keys to use the existing remote agents access check. - Updated localization strings to correct the descriptions for remote agent permissions, ensuring clarity in user interface. * fix: resource permission mapping to include remote agents - Changed the resourceToPermissionMap to use a Partial<Record> for better flexibility. - Added mapping for REMOTE_AGENT permissions, enhancing the sharing capabilities for remote agents. * feat: Implement remote access checks for agent models - Enhanced ListModelsController and GetModelController to include checks for user permissions on remote agents. - Integrated findAccessibleResources to filter agents based on VIEW permission for REMOTE_AGENT. - Updated response handling to ensure users can only access agents they have permissions for, improving security and access control. * fix: Update user parameter type in processUserPlaceholders function - Changed the user parameter type in the processUserPlaceholders function from Partial<Partial<IUser>> to Partial<IUser> for improved type clarity and consistency. * refactor: Simplify integration test structure by removing conditional describe - Replaced conditional describeWithApiKey with a standard describe for all integration tests in responses.spec.js. - This change enhances test clarity and ensures all tests are executed consistently, regardless of the SKIP_INTEGRATION_TESTS flag. * test: Update AgentFooter tests to reflect new grant access dialog ID - Changed test IDs for the grant access dialog in AgentFooter tests to include the resource type, ensuring accurate identification in the test cases. - This update improves test clarity and aligns with recent changes in the component's implementation. * test: Enhance integration tests for Open Responses API - Updated integration tests in responses.spec.js to utilize an authRequest helper for consistent authorization handling across all test cases. - Introduced a test user and API key creation to improve test setup and ensure proper permission checks for remote agents. - Added checks for existing access roles and created necessary roles if they do not exist, enhancing test reliability and coverage. * feat: Extend accessRole schema to include remoteAgent resource type - Updated the accessRole schema to add 'remoteAgent' to the resourceType enum, enhancing the flexibility of role assignments and permissions management. * test: refactored test setup to create a minimal Express app for responses routes, enhancing test structure and maintainability. * test: Enhance abort.spec.js by mocking additional modules for improved test isolation - Updated the test setup in abort.spec.js to include actual implementations of '@librechat/data-schemas' and '@librechat/api' while maintaining mock functionality. - This change improves test reliability and ensures that the tests are more representative of the actual module behavior. * refactor: Update conversation ID generation to use UUID - Replaced the nanoid with uuidv4 for generating conversation IDs in the createResponse function, enhancing uniqueness and consistency in ID generation. * test: Add remote agent access roles to AccessRole model tests - Included additional access roles for remote agents (REMOTE_AGENT_EDITOR, REMOTE_AGENT_OWNER, REMOTE_AGENT_VIEWER) in the AccessRole model tests to ensure comprehensive coverage of role assignments and permissions management. * chore: Add deletion of user agent API keys in user deletion process - Updated the user deletion process in UserController and delete-user.js to include the removal of user agent API keys, ensuring comprehensive cleanup of user data upon account deletion. * test: Add remote agents permissions to permissions.spec.ts - Enhanced the permissions tests by including comprehensive permission settings for remote agents across various scenarios, ensuring accurate validation of access controls for remote agent roles. * chore: Update remote agents translations for clarity and consistency - Removed outdated remote agents translation entries and added revised entries to improve clarity on API key creation and sharing permissions for remote agents. This enhances user understanding of the available functionalities. * feat: Add indexing and TTL for agent API keys - Introduced an index on the `key` field for improved query performance. - Added a TTL index on the `expiresAt` field to enable automatic cleanup of expired API keys, ensuring efficient management of stored keys. * chore: Update API route documentation for clarity - Revised comments in the agents route file to clarify the handling of API key authentication. - Removed outdated endpoint listings to streamline the documentation and focus on current functionality. --------- Co-authored-by: Max Sanna <max@maxsanna.com>
This commit is contained in:
Danny Avila
parent
dd4bbd38fc
commit
6279ea8dd7
70 changed files with 8926 additions and 50 deletions
|
|
@ -589,10 +589,16 @@ const deleteAgent = async (searchParameter) => {
|
|||
const agent = await Agent.findOneAndDelete(searchParameter);
|
||||
if (agent) {
|
||||
await removeAgentFromAllProjects(agent.id);
|
||||
await removeAllPermissions({
|
||||
resourceType: ResourceType.AGENT,
|
||||
resourceId: agent._id,
|
||||
});
|
||||
await Promise.all([
|
||||
removeAllPermissions({
|
||||
resourceType: ResourceType.AGENT,
|
||||
resourceId: agent._id,
|
||||
}),
|
||||
removeAllPermissions({
|
||||
resourceType: ResourceType.REMOTE_AGENT,
|
||||
resourceId: agent._id,
|
||||
}),
|
||||
]);
|
||||
try {
|
||||
await Agent.updateMany({ 'edges.to': agent.id }, { $pull: { edges: { to: agent.id } } });
|
||||
} catch (error) {
|
||||
|
|
@ -631,7 +637,7 @@ const deleteUserAgents = async (userId) => {
|
|||
}
|
||||
|
||||
await AclEntry.deleteMany({
|
||||
resourceType: ResourceType.AGENT,
|
||||
resourceType: { $in: [ResourceType.AGENT, ResourceType.REMOTE_AGENT] },
|
||||
resourceId: { $in: agentObjectIds },
|
||||
});
|
||||
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@
|
|||
const mongoose = require('mongoose');
|
||||
const { logger } = require('@librechat/data-schemas');
|
||||
const { ResourceType, PrincipalType, PermissionBits } = require('librechat-data-provider');
|
||||
const { enrichRemoteAgentPrincipals, backfillRemoteAgentPermissions } = require('@librechat/api');
|
||||
const {
|
||||
bulkUpdateResourcePermissions,
|
||||
ensureGroupPrincipalExists,
|
||||
|
|
@ -14,7 +15,6 @@ const {
|
|||
findAccessibleResources,
|
||||
getResourcePermissionsMap,
|
||||
} = require('~/server/services/PermissionService');
|
||||
const { AclEntry } = require('~/db/models');
|
||||
const {
|
||||
searchPrincipals: searchLocalPrincipals,
|
||||
sortPrincipalsByRelevance,
|
||||
|
|
@ -24,6 +24,7 @@ const {
|
|||
entraIdPrincipalFeatureEnabled,
|
||||
searchEntraIdPrincipals,
|
||||
} = require('~/server/services/GraphApiService');
|
||||
const { AclEntry, AccessRole } = require('~/db/models');
|
||||
|
||||
/**
|
||||
* Generic controller for resource permission endpoints
|
||||
|
|
@ -234,7 +235,7 @@ const getResourcePermissions = async (req, res) => {
|
|||
},
|
||||
]);
|
||||
|
||||
const principals = [];
|
||||
let principals = [];
|
||||
let publicPermission = null;
|
||||
|
||||
// Process aggregation results
|
||||
|
|
@ -280,6 +281,13 @@ const getResourcePermissions = async (req, res) => {
|
|||
}
|
||||
}
|
||||
|
||||
if (resourceType === ResourceType.REMOTE_AGENT) {
|
||||
const enricherDeps = { AclEntry, AccessRole, logger };
|
||||
const enrichResult = await enrichRemoteAgentPrincipals(enricherDeps, resourceId, principals);
|
||||
principals = enrichResult.principals;
|
||||
backfillRemoteAgentPermissions(enricherDeps, resourceId, enrichResult.entriesToBackfill);
|
||||
}
|
||||
|
||||
// Return response in format expected by frontend
|
||||
const response = {
|
||||
resourceType,
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ const {
|
|||
} = require('~/models');
|
||||
const {
|
||||
ConversationTag,
|
||||
AgentApiKey,
|
||||
Transaction,
|
||||
MemoryEntry,
|
||||
Assistant,
|
||||
|
|
@ -256,6 +257,7 @@ const deleteUserController = async (req, res) => {
|
|||
await deleteFiles(null, user.id); // delete database files in case of orphaned files from previous steps
|
||||
await deleteToolCalls(user.id); // delete user tool calls
|
||||
await deleteUserAgents(user.id); // delete user agents
|
||||
await AgentApiKey.deleteMany({ user: user._id }); // delete user agent API keys
|
||||
await Assistant.deleteMany({ user: user.id }); // delete user assistants
|
||||
await ConversationTag.deleteMany({ user: user.id }); // delete user conversation tags
|
||||
await MemoryEntry.deleteMany({ userId: user.id }); // delete user memory entries
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
const { nanoid } = require('nanoid');
|
||||
const { Constants } = require('@librechat/agents');
|
||||
const { logger } = require('@librechat/data-schemas');
|
||||
const { sendEvent, GenerationJobManager } = require('@librechat/api');
|
||||
const { sendEvent, GenerationJobManager, writeAttachmentEvent } = require('@librechat/api');
|
||||
const { Tools, StepTypes, FileContext, ErrorTypes } = require('librechat-data-provider');
|
||||
const {
|
||||
EnvVar,
|
||||
|
|
@ -489,7 +489,226 @@ function createToolEndCallback({ req, res, artifactPromises, streamId = null })
|
|||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper to write attachment events in Open Responses format (librechat:attachment)
|
||||
* @param {ServerResponse} res - The server response object
|
||||
* @param {Object} tracker - The response tracker with sequence number
|
||||
* @param {Object} attachment - The attachment data
|
||||
* @param {Object} metadata - Additional metadata (messageId, conversationId)
|
||||
*/
|
||||
function writeResponsesAttachment(res, tracker, attachment, metadata) {
|
||||
const sequenceNumber = tracker.nextSequence();
|
||||
writeAttachmentEvent(res, sequenceNumber, attachment, {
|
||||
messageId: metadata.run_id,
|
||||
conversationId: metadata.thread_id,
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a tool end callback specifically for the Responses API.
|
||||
* Emits attachments as `librechat:attachment` events per the Open Responses extension spec.
|
||||
*
|
||||
* @param {Object} params
|
||||
* @param {ServerRequest} params.req
|
||||
* @param {ServerResponse} params.res
|
||||
* @param {Object} params.tracker - Response tracker with sequence number
|
||||
* @param {Promise<MongoFile | { filename: string; filepath: string; expires: number;} | null>[]} params.artifactPromises
|
||||
* @returns {ToolEndCallback} The tool end callback.
|
||||
*/
|
||||
function createResponsesToolEndCallback({ req, res, tracker, artifactPromises }) {
|
||||
/**
|
||||
* @type {ToolEndCallback}
|
||||
*/
|
||||
return async (data, metadata) => {
|
||||
const output = data?.output;
|
||||
if (!output) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!output.artifact) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (output.artifact[Tools.file_search]) {
|
||||
artifactPromises.push(
|
||||
(async () => {
|
||||
const user = req.user;
|
||||
const attachment = await processFileCitations({
|
||||
user,
|
||||
metadata,
|
||||
appConfig: req.config,
|
||||
toolArtifact: output.artifact,
|
||||
toolCallId: output.tool_call_id,
|
||||
});
|
||||
if (!attachment) {
|
||||
return null;
|
||||
}
|
||||
// For Responses API, emit attachment during streaming
|
||||
if (res.headersSent && !res.writableEnded) {
|
||||
writeResponsesAttachment(res, tracker, attachment, metadata);
|
||||
}
|
||||
return attachment;
|
||||
})().catch((error) => {
|
||||
logger.error('Error processing file citations:', error);
|
||||
return null;
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
if (output.artifact[Tools.ui_resources]) {
|
||||
artifactPromises.push(
|
||||
(async () => {
|
||||
const attachment = {
|
||||
type: Tools.ui_resources,
|
||||
toolCallId: output.tool_call_id,
|
||||
[Tools.ui_resources]: output.artifact[Tools.ui_resources].data,
|
||||
};
|
||||
// For Responses API, always emit attachment during streaming
|
||||
if (res.headersSent && !res.writableEnded) {
|
||||
writeResponsesAttachment(res, tracker, attachment, metadata);
|
||||
}
|
||||
return attachment;
|
||||
})().catch((error) => {
|
||||
logger.error('Error processing artifact content:', error);
|
||||
return null;
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
if (output.artifact[Tools.web_search]) {
|
||||
artifactPromises.push(
|
||||
(async () => {
|
||||
const attachment = {
|
||||
type: Tools.web_search,
|
||||
toolCallId: output.tool_call_id,
|
||||
[Tools.web_search]: { ...output.artifact[Tools.web_search] },
|
||||
};
|
||||
// For Responses API, always emit attachment during streaming
|
||||
if (res.headersSent && !res.writableEnded) {
|
||||
writeResponsesAttachment(res, tracker, attachment, metadata);
|
||||
}
|
||||
return attachment;
|
||||
})().catch((error) => {
|
||||
logger.error('Error processing artifact content:', error);
|
||||
return null;
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
if (output.artifact.content) {
|
||||
/** @type {FormattedContent[]} */
|
||||
const content = output.artifact.content;
|
||||
for (let i = 0; i < content.length; i++) {
|
||||
const part = content[i];
|
||||
if (!part) {
|
||||
continue;
|
||||
}
|
||||
if (part.type !== 'image_url') {
|
||||
continue;
|
||||
}
|
||||
const { url } = part.image_url;
|
||||
artifactPromises.push(
|
||||
(async () => {
|
||||
const filename = `${output.name}_img_${nanoid()}`;
|
||||
const file_id = output.artifact.file_ids?.[i];
|
||||
const file = await saveBase64Image(url, {
|
||||
req,
|
||||
file_id,
|
||||
filename,
|
||||
endpoint: metadata.provider,
|
||||
context: FileContext.image_generation,
|
||||
});
|
||||
const fileMetadata = Object.assign(file, {
|
||||
toolCallId: output.tool_call_id,
|
||||
});
|
||||
|
||||
if (!fileMetadata) {
|
||||
return null;
|
||||
}
|
||||
|
||||
// For Responses API, emit attachment during streaming
|
||||
if (res.headersSent && !res.writableEnded) {
|
||||
const attachment = {
|
||||
file_id: fileMetadata.file_id,
|
||||
filename: fileMetadata.filename,
|
||||
type: fileMetadata.type,
|
||||
url: fileMetadata.filepath,
|
||||
width: fileMetadata.width,
|
||||
height: fileMetadata.height,
|
||||
tool_call_id: output.tool_call_id,
|
||||
};
|
||||
writeResponsesAttachment(res, tracker, attachment, metadata);
|
||||
}
|
||||
|
||||
return fileMetadata;
|
||||
})().catch((error) => {
|
||||
logger.error('Error processing artifact content:', error);
|
||||
return null;
|
||||
}),
|
||||
);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
const isCodeTool =
|
||||
output.name === Tools.execute_code || output.name === Constants.PROGRAMMATIC_TOOL_CALLING;
|
||||
if (!isCodeTool) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!output.artifact.files) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (const file of output.artifact.files) {
|
||||
const { id, name } = file;
|
||||
artifactPromises.push(
|
||||
(async () => {
|
||||
const result = await loadAuthValues({
|
||||
userId: req.user.id,
|
||||
authFields: [EnvVar.CODE_API_KEY],
|
||||
});
|
||||
const fileMetadata = await processCodeOutput({
|
||||
req,
|
||||
id,
|
||||
name,
|
||||
apiKey: result[EnvVar.CODE_API_KEY],
|
||||
messageId: metadata.run_id,
|
||||
toolCallId: output.tool_call_id,
|
||||
conversationId: metadata.thread_id,
|
||||
session_id: output.artifact.session_id,
|
||||
});
|
||||
|
||||
if (!fileMetadata) {
|
||||
return null;
|
||||
}
|
||||
|
||||
// For Responses API, emit attachment during streaming
|
||||
if (res.headersSent && !res.writableEnded) {
|
||||
const attachment = {
|
||||
file_id: fileMetadata.file_id,
|
||||
filename: fileMetadata.filename,
|
||||
type: fileMetadata.type,
|
||||
url: fileMetadata.filepath,
|
||||
width: fileMetadata.width,
|
||||
height: fileMetadata.height,
|
||||
tool_call_id: output.tool_call_id,
|
||||
};
|
||||
writeResponsesAttachment(res, tracker, attachment, metadata);
|
||||
}
|
||||
|
||||
return fileMetadata;
|
||||
})().catch((error) => {
|
||||
logger.error('Error processing code output:', error);
|
||||
return null;
|
||||
}),
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
getDefaultHandlers,
|
||||
createToolEndCallback,
|
||||
createResponsesToolEndCallback,
|
||||
};
|
||||
|
|
|
|||
660
api/server/controllers/agents/openai.js
Normal file
660
api/server/controllers/agents/openai.js
Normal file
|
|
@ -0,0 +1,660 @@
|
|||
const { nanoid } = require('nanoid');
|
||||
const { logger } = require('@librechat/data-schemas');
|
||||
const { EModelEndpoint, ResourceType, PermissionBits } = require('librechat-data-provider');
|
||||
const {
|
||||
Callback,
|
||||
ToolEndHandler,
|
||||
formatAgentMessages,
|
||||
ChatModelStreamHandler,
|
||||
} = require('@librechat/agents');
|
||||
const {
|
||||
writeSSE,
|
||||
createRun,
|
||||
createChunk,
|
||||
sendFinalChunk,
|
||||
createSafeUser,
|
||||
validateRequest,
|
||||
initializeAgent,
|
||||
createErrorResponse,
|
||||
buildNonStreamingResponse,
|
||||
createOpenAIStreamTracker,
|
||||
createOpenAIContentAggregator,
|
||||
isChatCompletionValidationFailure,
|
||||
} = require('@librechat/api');
|
||||
const { createToolEndCallback } = require('~/server/controllers/agents/callbacks');
|
||||
const { findAccessibleResources } = require('~/server/services/PermissionService');
|
||||
const { loadAgentTools } = require('~/server/services/ToolService');
|
||||
const { getConvoFiles } = require('~/models/Conversation');
|
||||
const { getAgent, getAgents } = require('~/models/Agent');
|
||||
const db = require('~/models');
|
||||
|
||||
/**
|
||||
* Creates a tool loader function for the agent.
|
||||
* @param {AbortSignal} signal - The abort signal
|
||||
*/
|
||||
function createToolLoader(signal) {
|
||||
return async function loadTools({
|
||||
req,
|
||||
res,
|
||||
tools,
|
||||
model,
|
||||
agentId,
|
||||
provider,
|
||||
tool_options,
|
||||
tool_resources,
|
||||
}) {
|
||||
const agent = { id: agentId, tools, provider, model, tool_options };
|
||||
try {
|
||||
return await loadAgentTools({
|
||||
req,
|
||||
res,
|
||||
agent,
|
||||
signal,
|
||||
tool_resources,
|
||||
streamId: null, // No resumable stream for OpenAI compat
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Error loading tools for agent ' + agentId, error);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert content part to internal format
|
||||
* @param {Object} part - Content part
|
||||
* @returns {Object} Converted part
|
||||
*/
|
||||
function convertContentPart(part) {
|
||||
if (part.type === 'text') {
|
||||
return { type: 'text', text: part.text };
|
||||
}
|
||||
if (part.type === 'image_url') {
|
||||
return { type: 'image_url', image_url: part.image_url };
|
||||
}
|
||||
return part;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert OpenAI messages to internal format
|
||||
* @param {Array} messages - OpenAI format messages
|
||||
* @returns {Array} Internal format messages
|
||||
*/
|
||||
function convertMessages(messages) {
|
||||
return messages.map((msg) => {
|
||||
let content;
|
||||
if (typeof msg.content === 'string') {
|
||||
content = msg.content;
|
||||
} else if (msg.content) {
|
||||
content = msg.content.map(convertContentPart);
|
||||
} else {
|
||||
content = '';
|
||||
}
|
||||
|
||||
return {
|
||||
role: msg.role,
|
||||
content,
|
||||
...(msg.name && { name: msg.name }),
|
||||
...(msg.tool_calls && { tool_calls: msg.tool_calls }),
|
||||
...(msg.tool_call_id && { tool_call_id: msg.tool_call_id }),
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Send an error response in OpenAI format
|
||||
*/
|
||||
function sendErrorResponse(res, statusCode, message, type = 'invalid_request_error', code = null) {
|
||||
res.status(statusCode).json(createErrorResponse(message, type, code));
|
||||
}
|
||||
|
||||
/**
|
||||
* OpenAI-compatible chat completions controller for agents.
|
||||
*
|
||||
* POST /v1/chat/completions
|
||||
*
|
||||
* Request format:
|
||||
* {
|
||||
* "model": "agent_id_here",
|
||||
* "messages": [{"role": "user", "content": "Hello!"}],
|
||||
* "stream": true,
|
||||
* "conversation_id": "optional",
|
||||
* "parent_message_id": "optional"
|
||||
* }
|
||||
*/
|
||||
const OpenAIChatCompletionController = async (req, res) => {
|
||||
const appConfig = req.config;
|
||||
|
||||
// Validate request
|
||||
const validation = validateRequest(req.body);
|
||||
if (isChatCompletionValidationFailure(validation)) {
|
||||
return sendErrorResponse(res, 400, validation.error);
|
||||
}
|
||||
|
||||
const request = validation.request;
|
||||
const agentId = request.model;
|
||||
|
||||
// Look up the agent
|
||||
const agent = await getAgent({ id: agentId });
|
||||
if (!agent) {
|
||||
return sendErrorResponse(
|
||||
res,
|
||||
404,
|
||||
`Agent not found: ${agentId}`,
|
||||
'invalid_request_error',
|
||||
'model_not_found',
|
||||
);
|
||||
}
|
||||
|
||||
// Generate IDs
|
||||
const requestId = `chatcmpl-${nanoid()}`;
|
||||
const conversationId = request.conversation_id ?? nanoid();
|
||||
const parentMessageId = request.parent_message_id ?? null;
|
||||
const created = Math.floor(Date.now() / 1000);
|
||||
|
||||
const context = {
|
||||
created,
|
||||
requestId,
|
||||
model: agentId,
|
||||
};
|
||||
|
||||
// Set up abort controller
|
||||
const abortController = new AbortController();
|
||||
|
||||
// Handle client disconnect
|
||||
req.on('close', () => {
|
||||
if (!abortController.signal.aborted) {
|
||||
abortController.abort();
|
||||
logger.debug('[OpenAI API] Client disconnected, aborting');
|
||||
}
|
||||
});
|
||||
|
||||
try {
|
||||
// Build allowed providers set
|
||||
const allowedProviders = new Set(
|
||||
appConfig?.endpoints?.[EModelEndpoint.agents]?.allowedProviders,
|
||||
);
|
||||
|
||||
// Create tool loader
|
||||
const loadTools = createToolLoader(abortController.signal);
|
||||
|
||||
// Initialize the agent first to check for disableStreaming
|
||||
const endpointOption = {
|
||||
endpoint: agent.provider,
|
||||
model_parameters: agent.model_parameters ?? {},
|
||||
};
|
||||
|
||||
const primaryConfig = await initializeAgent(
|
||||
{
|
||||
req,
|
||||
res,
|
||||
loadTools,
|
||||
requestFiles: [],
|
||||
conversationId,
|
||||
parentMessageId,
|
||||
agent,
|
||||
endpointOption,
|
||||
allowedProviders,
|
||||
isInitialAgent: true,
|
||||
},
|
||||
{
|
||||
getConvoFiles,
|
||||
getFiles: db.getFiles,
|
||||
getUserKey: db.getUserKey,
|
||||
getMessages: db.getMessages,
|
||||
updateFilesUsage: db.updateFilesUsage,
|
||||
getUserKeyValues: db.getUserKeyValues,
|
||||
getUserCodeFiles: db.getUserCodeFiles,
|
||||
getToolFilesByIds: db.getToolFilesByIds,
|
||||
getCodeGeneratedFiles: db.getCodeGeneratedFiles,
|
||||
},
|
||||
);
|
||||
|
||||
// Determine if streaming is enabled (check both request and agent config)
|
||||
const streamingDisabled = !!primaryConfig.model_parameters?.disableStreaming;
|
||||
const isStreaming = request.stream === true && !streamingDisabled;
|
||||
|
||||
// Create tracker for streaming or aggregator for non-streaming
|
||||
const tracker = isStreaming ? createOpenAIStreamTracker() : null;
|
||||
const aggregator = isStreaming ? null : createOpenAIContentAggregator();
|
||||
|
||||
// Set up response for streaming
|
||||
if (isStreaming) {
|
||||
res.setHeader('Content-Type', 'text/event-stream');
|
||||
res.setHeader('Cache-Control', 'no-cache');
|
||||
res.setHeader('Connection', 'keep-alive');
|
||||
res.setHeader('X-Accel-Buffering', 'no');
|
||||
res.flushHeaders();
|
||||
|
||||
// Send initial chunk with role
|
||||
const initialChunk = createChunk(context, { role: 'assistant' });
|
||||
writeSSE(res, initialChunk);
|
||||
}
|
||||
|
||||
// Create handler config for OpenAI streaming (only used when streaming)
|
||||
const handlerConfig = isStreaming
|
||||
? {
|
||||
res,
|
||||
context,
|
||||
tracker,
|
||||
}
|
||||
: null;
|
||||
|
||||
// We need custom handlers that stream in OpenAI format
|
||||
const collectedUsage = [];
|
||||
/** @type {Promise<import('librechat-data-provider').TAttachment | null>[]} */
|
||||
const artifactPromises = [];
|
||||
|
||||
// Create tool end callback for processing artifacts (images, file citations, code output)
|
||||
const toolEndCallback = createToolEndCallback({ req, res, artifactPromises, streamId: null });
|
||||
|
||||
// Convert messages to internal format
|
||||
const openaiMessages = convertMessages(request.messages);
|
||||
|
||||
// Format for agent
|
||||
const toolSet = new Set((primaryConfig.tools ?? []).map((tool) => tool && tool.name));
|
||||
const { messages: formattedMessages, indexTokenCountMap } = formatAgentMessages(
|
||||
openaiMessages,
|
||||
{},
|
||||
toolSet,
|
||||
);
|
||||
|
||||
/**
|
||||
* Create a simple handler that processes data
|
||||
*/
|
||||
const createHandler = (processor) => ({
|
||||
handle: (_event, data) => {
|
||||
if (processor) {
|
||||
processor(data);
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
/**
|
||||
* Stream text content in OpenAI format
|
||||
*/
|
||||
const streamText = (text) => {
|
||||
if (!text) {
|
||||
return;
|
||||
}
|
||||
if (isStreaming) {
|
||||
tracker.addText();
|
||||
writeSSE(res, createChunk(context, { content: text }));
|
||||
} else {
|
||||
aggregator.addText(text);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Stream reasoning content in OpenAI format (OpenRouter convention)
|
||||
*/
|
||||
const streamReasoning = (text) => {
|
||||
if (!text) {
|
||||
return;
|
||||
}
|
||||
if (isStreaming) {
|
||||
tracker.addReasoning();
|
||||
writeSSE(res, createChunk(context, { reasoning: text }));
|
||||
} else {
|
||||
aggregator.addReasoning(text);
|
||||
}
|
||||
};
|
||||
|
||||
// Built-in handler for processing raw model stream chunks
|
||||
const chatModelStreamHandler = new ChatModelStreamHandler();
|
||||
|
||||
// Event handlers for OpenAI-compatible streaming
|
||||
const handlers = {
|
||||
// Process raw model chunks and dispatch message/reasoning deltas
|
||||
on_chat_model_stream: {
|
||||
handle: async (event, data, metadata, graph) => {
|
||||
await chatModelStreamHandler.handle(event, data, metadata, graph);
|
||||
},
|
||||
},
|
||||
|
||||
// Text content streaming
|
||||
on_message_delta: createHandler((data) => {
|
||||
const content = data?.delta?.content;
|
||||
if (Array.isArray(content)) {
|
||||
for (const part of content) {
|
||||
if (part.type === 'text' && part.text) {
|
||||
streamText(part.text);
|
||||
}
|
||||
}
|
||||
}
|
||||
}),
|
||||
|
||||
// Reasoning/thinking content streaming
|
||||
on_reasoning_delta: createHandler((data) => {
|
||||
const content = data?.delta?.content;
|
||||
if (Array.isArray(content)) {
|
||||
for (const part of content) {
|
||||
const text = part.think || part.text;
|
||||
if (text) {
|
||||
streamReasoning(text);
|
||||
}
|
||||
}
|
||||
}
|
||||
}),
|
||||
|
||||
// Tool call initiation - streams id and name (from on_run_step)
|
||||
on_run_step: createHandler((data) => {
|
||||
const stepDetails = data?.stepDetails;
|
||||
if (stepDetails?.type === 'tool_calls' && stepDetails.tool_calls) {
|
||||
for (const tc of stepDetails.tool_calls) {
|
||||
const toolIndex = data.index ?? 0;
|
||||
const toolId = tc.id ?? '';
|
||||
const toolName = tc.name ?? '';
|
||||
const toolCall = {
|
||||
id: toolId,
|
||||
type: 'function',
|
||||
function: { name: toolName, arguments: '' },
|
||||
};
|
||||
|
||||
// Track tool call in tracker or aggregator
|
||||
if (isStreaming) {
|
||||
if (!tracker.toolCalls.has(toolIndex)) {
|
||||
tracker.toolCalls.set(toolIndex, toolCall);
|
||||
}
|
||||
// Stream initial tool call chunk (like OpenAI does)
|
||||
writeSSE(
|
||||
res,
|
||||
createChunk(context, {
|
||||
tool_calls: [{ index: toolIndex, ...toolCall }],
|
||||
}),
|
||||
);
|
||||
} else {
|
||||
if (!aggregator.toolCalls.has(toolIndex)) {
|
||||
aggregator.toolCalls.set(toolIndex, toolCall);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}),
|
||||
|
||||
// Tool call argument streaming (from on_run_step_delta)
|
||||
on_run_step_delta: createHandler((data) => {
|
||||
const delta = data?.delta;
|
||||
if (delta?.type === 'tool_calls' && delta.tool_calls) {
|
||||
for (const tc of delta.tool_calls) {
|
||||
const args = tc.args ?? '';
|
||||
if (!args) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const toolIndex = tc.index ?? 0;
|
||||
|
||||
// Update tool call arguments
|
||||
const targetMap = isStreaming ? tracker.toolCalls : aggregator.toolCalls;
|
||||
const tracked = targetMap.get(toolIndex);
|
||||
if (tracked) {
|
||||
tracked.function.arguments += args;
|
||||
}
|
||||
|
||||
// Stream argument delta (only for streaming)
|
||||
if (isStreaming) {
|
||||
writeSSE(
|
||||
res,
|
||||
createChunk(context, {
|
||||
tool_calls: [
|
||||
{
|
||||
index: toolIndex,
|
||||
function: { arguments: args },
|
||||
},
|
||||
],
|
||||
}),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}),
|
||||
|
||||
// Usage tracking
|
||||
on_chat_model_end: createHandler((data) => {
|
||||
const usage = data?.output?.usage_metadata;
|
||||
if (usage) {
|
||||
collectedUsage.push(usage);
|
||||
const target = isStreaming ? tracker : aggregator;
|
||||
target.usage.promptTokens += usage.input_tokens ?? 0;
|
||||
target.usage.completionTokens += usage.output_tokens ?? 0;
|
||||
}
|
||||
}),
|
||||
on_run_step_completed: createHandler(),
|
||||
// Use proper ToolEndHandler for processing artifacts (images, file citations, code output)
|
||||
on_tool_end: new ToolEndHandler(toolEndCallback, logger),
|
||||
on_chain_stream: createHandler(),
|
||||
on_chain_end: createHandler(),
|
||||
on_agent_update: createHandler(),
|
||||
on_custom_event: createHandler(),
|
||||
};
|
||||
|
||||
// Create and run the agent
|
||||
const userId = req.user?.id ?? 'api-user';
|
||||
|
||||
// Extract userMCPAuthMap from primaryConfig (needed for MCP tool connections)
|
||||
const userMCPAuthMap = primaryConfig.userMCPAuthMap;
|
||||
|
||||
const run = await createRun({
|
||||
agents: [primaryConfig],
|
||||
messages: formattedMessages,
|
||||
indexTokenCountMap,
|
||||
runId: requestId,
|
||||
signal: abortController.signal,
|
||||
customHandlers: handlers,
|
||||
requestBody: {
|
||||
messageId: requestId,
|
||||
conversationId,
|
||||
},
|
||||
user: { id: userId },
|
||||
});
|
||||
|
||||
if (!run) {
|
||||
throw new Error('Failed to create agent run');
|
||||
}
|
||||
|
||||
// Process the stream
|
||||
const config = {
|
||||
runName: 'AgentRun',
|
||||
configurable: {
|
||||
thread_id: conversationId,
|
||||
user_id: userId,
|
||||
user: createSafeUser(req.user),
|
||||
...(userMCPAuthMap != null && { userMCPAuthMap }),
|
||||
},
|
||||
signal: abortController.signal,
|
||||
streamMode: 'values',
|
||||
version: 'v2',
|
||||
};
|
||||
|
||||
await run.processStream({ messages: formattedMessages }, config, {
|
||||
callbacks: {
|
||||
[Callback.TOOL_ERROR]: (graph, error, toolId) => {
|
||||
logger.error(`[OpenAI API] Tool Error "${toolId}"`, error);
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
// Finalize response
|
||||
if (isStreaming) {
|
||||
sendFinalChunk(handlerConfig);
|
||||
res.end();
|
||||
|
||||
// Wait for artifact processing after response ends (non-blocking)
|
||||
if (artifactPromises.length > 0) {
|
||||
Promise.all(artifactPromises).catch((artifactError) => {
|
||||
logger.warn('[OpenAI API] Error processing artifacts:', artifactError);
|
||||
});
|
||||
}
|
||||
} else {
|
||||
// For non-streaming, wait for artifacts before sending response
|
||||
if (artifactPromises.length > 0) {
|
||||
try {
|
||||
await Promise.all(artifactPromises);
|
||||
} catch (artifactError) {
|
||||
logger.warn('[OpenAI API] Error processing artifacts:', artifactError);
|
||||
}
|
||||
}
|
||||
|
||||
// Build usage from aggregated data
|
||||
const usage = {
|
||||
prompt_tokens: aggregator.usage.promptTokens,
|
||||
completion_tokens: aggregator.usage.completionTokens,
|
||||
total_tokens: aggregator.usage.promptTokens + aggregator.usage.completionTokens,
|
||||
};
|
||||
|
||||
if (aggregator.usage.reasoningTokens > 0) {
|
||||
usage.completion_tokens_details = {
|
||||
reasoning_tokens: aggregator.usage.reasoningTokens,
|
||||
};
|
||||
}
|
||||
|
||||
const response = buildNonStreamingResponse(
|
||||
context,
|
||||
aggregator.getText(),
|
||||
aggregator.getReasoning(),
|
||||
aggregator.toolCalls,
|
||||
usage,
|
||||
);
|
||||
res.json(response);
|
||||
}
|
||||
} catch (error) {
|
||||
const errorMessage = error instanceof Error ? error.message : 'An error occurred';
|
||||
logger.error('[OpenAI API] Error:', error);
|
||||
|
||||
// Check if we already started streaming (headers sent)
|
||||
if (res.headersSent) {
|
||||
// Headers already sent, send error in stream
|
||||
const errorChunk = createChunk(context, { content: `\n\nError: ${errorMessage}` }, 'stop');
|
||||
writeSSE(res, errorChunk);
|
||||
writeSSE(res, '[DONE]');
|
||||
res.end();
|
||||
} else {
|
||||
sendErrorResponse(res, 500, errorMessage, 'server_error');
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* List available agents as models (filtered by remote access permissions)
|
||||
*
|
||||
* GET /v1/models
|
||||
*/
|
||||
const ListModelsController = async (req, res) => {
|
||||
try {
|
||||
const userId = req.user?.id;
|
||||
const userRole = req.user?.role;
|
||||
|
||||
if (!userId) {
|
||||
return sendErrorResponse(res, 401, 'Authentication required', 'auth_error');
|
||||
}
|
||||
|
||||
// Find agents the user has remote access to (VIEW permission on REMOTE_AGENT)
|
||||
const accessibleAgentIds = await findAccessibleResources({
|
||||
userId,
|
||||
role: userRole,
|
||||
resourceType: ResourceType.REMOTE_AGENT,
|
||||
requiredPermissions: PermissionBits.VIEW,
|
||||
});
|
||||
|
||||
// Get the accessible agents
|
||||
let agents = [];
|
||||
if (accessibleAgentIds.length > 0) {
|
||||
agents = await getAgents({ _id: { $in: accessibleAgentIds } });
|
||||
}
|
||||
|
||||
const models = agents.map((agent) => ({
|
||||
id: agent.id,
|
||||
object: 'model',
|
||||
created: Math.floor(new Date(agent.createdAt || Date.now()).getTime() / 1000),
|
||||
owned_by: 'librechat',
|
||||
permission: [],
|
||||
root: agent.id,
|
||||
parent: null,
|
||||
// LibreChat extensions
|
||||
name: agent.name,
|
||||
description: agent.description,
|
||||
provider: agent.provider,
|
||||
}));
|
||||
|
||||
res.json({
|
||||
object: 'list',
|
||||
data: models,
|
||||
});
|
||||
} catch (error) {
|
||||
const errorMessage = error instanceof Error ? error.message : 'Failed to list models';
|
||||
logger.error('[OpenAI API] Error listing models:', error);
|
||||
sendErrorResponse(res, 500, errorMessage, 'server_error');
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Get a specific model/agent (with remote access permission check)
|
||||
*
|
||||
* GET /v1/models/:model
|
||||
*/
|
||||
const GetModelController = async (req, res) => {
|
||||
try {
|
||||
const { model } = req.params;
|
||||
const userId = req.user?.id;
|
||||
const userRole = req.user?.role;
|
||||
|
||||
if (!userId) {
|
||||
return sendErrorResponse(res, 401, 'Authentication required', 'auth_error');
|
||||
}
|
||||
|
||||
const agent = await getAgent({ id: model });
|
||||
|
||||
if (!agent) {
|
||||
return sendErrorResponse(
|
||||
res,
|
||||
404,
|
||||
`Model not found: ${model}`,
|
||||
'invalid_request_error',
|
||||
'model_not_found',
|
||||
);
|
||||
}
|
||||
|
||||
// Check if user has remote access to this agent
|
||||
const accessibleAgentIds = await findAccessibleResources({
|
||||
userId,
|
||||
role: userRole,
|
||||
resourceType: ResourceType.REMOTE_AGENT,
|
||||
requiredPermissions: PermissionBits.VIEW,
|
||||
});
|
||||
|
||||
const hasAccess = accessibleAgentIds.some((id) => id.toString() === agent._id.toString());
|
||||
|
||||
if (!hasAccess) {
|
||||
return sendErrorResponse(
|
||||
res,
|
||||
403,
|
||||
`No remote access to model: ${model}`,
|
||||
'permission_error',
|
||||
'access_denied',
|
||||
);
|
||||
}
|
||||
|
||||
res.json({
|
||||
id: agent.id,
|
||||
object: 'model',
|
||||
created: Math.floor(new Date(agent.createdAt || Date.now()).getTime() / 1000),
|
||||
owned_by: 'librechat',
|
||||
permission: [],
|
||||
root: agent.id,
|
||||
parent: null,
|
||||
// LibreChat extensions
|
||||
name: agent.name,
|
||||
description: agent.description,
|
||||
provider: agent.provider,
|
||||
});
|
||||
} catch (error) {
|
||||
const errorMessage = error instanceof Error ? error.message : 'Failed to get model';
|
||||
logger.error('[OpenAI API] Error getting model:', error);
|
||||
sendErrorResponse(res, 500, errorMessage, 'server_error');
|
||||
}
|
||||
};
|
||||
|
||||
module.exports = {
|
||||
OpenAIChatCompletionController,
|
||||
ListModelsController,
|
||||
GetModelController,
|
||||
};
|
||||
800
api/server/controllers/agents/responses.js
Normal file
800
api/server/controllers/agents/responses.js
Normal file
|
|
@ -0,0 +1,800 @@
|
|||
const { nanoid } = require('nanoid');
|
||||
const { v4: uuidv4 } = require('uuid');
|
||||
const { logger } = require('@librechat/data-schemas');
|
||||
const { EModelEndpoint, ResourceType, PermissionBits } = require('librechat-data-provider');
|
||||
const {
|
||||
Callback,
|
||||
ToolEndHandler,
|
||||
formatAgentMessages,
|
||||
ChatModelStreamHandler,
|
||||
} = require('@librechat/agents');
|
||||
const {
|
||||
createRun,
|
||||
createSafeUser,
|
||||
initializeAgent,
|
||||
// Responses API
|
||||
writeDone,
|
||||
buildResponse,
|
||||
generateResponseId,
|
||||
isValidationFailure,
|
||||
emitResponseCreated,
|
||||
createResponseContext,
|
||||
createResponseTracker,
|
||||
setupStreamingResponse,
|
||||
emitResponseInProgress,
|
||||
convertInputToMessages,
|
||||
validateResponseRequest,
|
||||
buildAggregatedResponse,
|
||||
createResponseAggregator,
|
||||
sendResponsesErrorResponse,
|
||||
createResponsesEventHandlers,
|
||||
createAggregatorEventHandlers,
|
||||
} = require('@librechat/api');
|
||||
const {
|
||||
createResponsesToolEndCallback,
|
||||
createToolEndCallback,
|
||||
} = require('~/server/controllers/agents/callbacks');
|
||||
const { findAccessibleResources } = require('~/server/services/PermissionService');
|
||||
const { getConvoFiles, saveConvo, getConvo } = require('~/models/Conversation');
|
||||
const { loadAgentTools } = require('~/server/services/ToolService');
|
||||
const { getAgent, getAgents } = require('~/models/Agent');
|
||||
const db = require('~/models');
|
||||
|
||||
/** @type {import('@librechat/api').AppConfig | null} */
|
||||
let appConfig = null;
|
||||
|
||||
/**
|
||||
* Set the app config for the controller
|
||||
* @param {import('@librechat/api').AppConfig} config
|
||||
*/
|
||||
function setAppConfig(config) {
|
||||
appConfig = config;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a tool loader function for the agent.
|
||||
* @param {AbortSignal} signal - The abort signal
|
||||
*/
|
||||
function createToolLoader(signal) {
|
||||
return async function loadTools({
|
||||
req,
|
||||
res,
|
||||
tools,
|
||||
model,
|
||||
agentId,
|
||||
provider,
|
||||
tool_options,
|
||||
tool_resources,
|
||||
}) {
|
||||
const agent = { id: agentId, tools, provider, model, tool_options };
|
||||
try {
|
||||
return await loadAgentTools({
|
||||
req,
|
||||
res,
|
||||
agent,
|
||||
signal,
|
||||
tool_resources,
|
||||
streamId: null,
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Error loading tools for agent ' + agentId, error);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert Open Responses input items to internal messages
|
||||
* @param {import('@librechat/api').InputItem[]} input
|
||||
* @returns {Array} Internal messages
|
||||
*/
|
||||
function convertToInternalMessages(input) {
|
||||
return convertInputToMessages(input);
|
||||
}
|
||||
|
||||
/**
|
||||
* Load messages from a previous response/conversation
|
||||
* @param {string} conversationId - The conversation/response ID
|
||||
* @param {string} userId - The user ID
|
||||
* @returns {Promise<Array>} Messages from the conversation
|
||||
*/
|
||||
async function loadPreviousMessages(conversationId, userId) {
|
||||
try {
|
||||
const messages = await db.getMessages({ conversationId, user: userId });
|
||||
if (!messages || messages.length === 0) {
|
||||
return [];
|
||||
}
|
||||
|
||||
// Convert stored messages to internal format
|
||||
return messages.map((msg) => {
|
||||
const internalMsg = {
|
||||
role: msg.isCreatedByUser ? 'user' : 'assistant',
|
||||
content: '',
|
||||
messageId: msg.messageId,
|
||||
};
|
||||
|
||||
// Handle content - could be string or array
|
||||
if (typeof msg.text === 'string') {
|
||||
internalMsg.content = msg.text;
|
||||
} else if (Array.isArray(msg.content)) {
|
||||
// Handle content parts
|
||||
internalMsg.content = msg.content;
|
||||
} else if (msg.text) {
|
||||
internalMsg.content = String(msg.text);
|
||||
}
|
||||
|
||||
return internalMsg;
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('[Responses API] Error loading previous messages:', error);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Save input messages to database
|
||||
* @param {import('express').Request} req
|
||||
* @param {string} conversationId
|
||||
* @param {Array} inputMessages - Internal format messages
|
||||
* @param {string} agentId
|
||||
* @returns {Promise<void>}
|
||||
*/
|
||||
async function saveInputMessages(req, conversationId, inputMessages, agentId) {
|
||||
for (const msg of inputMessages) {
|
||||
if (msg.role === 'user') {
|
||||
await db.saveMessage(
|
||||
req,
|
||||
{
|
||||
messageId: msg.messageId || nanoid(),
|
||||
conversationId,
|
||||
parentMessageId: null,
|
||||
isCreatedByUser: true,
|
||||
text: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
|
||||
sender: 'User',
|
||||
endpoint: EModelEndpoint.agents,
|
||||
model: agentId,
|
||||
},
|
||||
{ context: 'Responses API - save user input' },
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Save response output to database
|
||||
* @param {import('express').Request} req
|
||||
* @param {string} conversationId
|
||||
* @param {string} responseId
|
||||
* @param {import('@librechat/api').Response} response
|
||||
* @param {string} agentId
|
||||
* @returns {Promise<void>}
|
||||
*/
|
||||
async function saveResponseOutput(req, conversationId, responseId, response, agentId) {
|
||||
// Extract text content from output items
|
||||
let responseText = '';
|
||||
for (const item of response.output) {
|
||||
if (item.type === 'message' && item.content) {
|
||||
for (const part of item.content) {
|
||||
if (part.type === 'output_text' && part.text) {
|
||||
responseText += part.text;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Save the assistant message
|
||||
await db.saveMessage(
|
||||
req,
|
||||
{
|
||||
messageId: responseId,
|
||||
conversationId,
|
||||
parentMessageId: null,
|
||||
isCreatedByUser: false,
|
||||
text: responseText,
|
||||
sender: 'Agent',
|
||||
endpoint: EModelEndpoint.agents,
|
||||
model: agentId,
|
||||
finish_reason: response.status === 'completed' ? 'stop' : response.status,
|
||||
tokenCount: response.usage?.output_tokens,
|
||||
},
|
||||
{ context: 'Responses API - save assistant response' },
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Save or update conversation
|
||||
* @param {import('express').Request} req
|
||||
* @param {string} conversationId
|
||||
* @param {string} agentId
|
||||
* @param {object} agent
|
||||
* @returns {Promise<void>}
|
||||
*/
|
||||
async function saveConversation(req, conversationId, agentId, agent) {
|
||||
await saveConvo(
|
||||
req,
|
||||
{
|
||||
conversationId,
|
||||
endpoint: EModelEndpoint.agents,
|
||||
agentId,
|
||||
title: agent?.name || 'Open Responses Conversation',
|
||||
model: agent?.model,
|
||||
},
|
||||
{ context: 'Responses API - save conversation' },
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert stored messages to Open Responses output format
|
||||
* @param {Array} messages - Stored messages
|
||||
* @returns {Array} Output items
|
||||
*/
|
||||
function convertMessagesToOutputItems(messages) {
|
||||
const output = [];
|
||||
|
||||
for (const msg of messages) {
|
||||
if (!msg.isCreatedByUser) {
|
||||
output.push({
|
||||
type: 'message',
|
||||
id: msg.messageId,
|
||||
role: 'assistant',
|
||||
status: 'completed',
|
||||
content: [
|
||||
{
|
||||
type: 'output_text',
|
||||
text: msg.text || '',
|
||||
annotations: [],
|
||||
},
|
||||
],
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create Response - POST /v1/responses
|
||||
*
|
||||
* Creates a model response following the Open Responses API specification.
|
||||
* Supports both streaming and non-streaming responses.
|
||||
*
|
||||
* @param {import('express').Request} req
|
||||
* @param {import('express').Response} res
|
||||
*/
|
||||
const createResponse = async (req, res) => {
|
||||
// Validate request
|
||||
const validation = validateResponseRequest(req.body);
|
||||
if (isValidationFailure(validation)) {
|
||||
return sendResponsesErrorResponse(res, 400, validation.error);
|
||||
}
|
||||
|
||||
const request = validation.request;
|
||||
const agentId = request.model;
|
||||
const isStreaming = request.stream === true;
|
||||
|
||||
// Look up the agent
|
||||
const agent = await getAgent({ id: agentId });
|
||||
if (!agent) {
|
||||
return sendResponsesErrorResponse(
|
||||
res,
|
||||
404,
|
||||
`Agent not found: ${agentId}`,
|
||||
'not_found',
|
||||
'model_not_found',
|
||||
);
|
||||
}
|
||||
|
||||
// Generate IDs
|
||||
const responseId = generateResponseId();
|
||||
const conversationId = request.previous_response_id ?? uuidv4();
|
||||
const parentMessageId = null;
|
||||
|
||||
// Create response context
|
||||
const context = createResponseContext(request, responseId);
|
||||
|
||||
// Set up abort controller
|
||||
const abortController = new AbortController();
|
||||
|
||||
// Handle client disconnect
|
||||
req.on('close', () => {
|
||||
if (!abortController.signal.aborted) {
|
||||
abortController.abort();
|
||||
logger.debug('[Responses API] Client disconnected, aborting');
|
||||
}
|
||||
});
|
||||
|
||||
try {
|
||||
// Build allowed providers set
|
||||
const allowedProviders = new Set(
|
||||
appConfig?.endpoints?.[EModelEndpoint.agents]?.allowedProviders,
|
||||
);
|
||||
|
||||
// Create tool loader
|
||||
const loadTools = createToolLoader(abortController.signal);
|
||||
|
||||
// Initialize the agent first to check for disableStreaming
|
||||
const endpointOption = {
|
||||
endpoint: agent.provider,
|
||||
model_parameters: agent.model_parameters ?? {},
|
||||
};
|
||||
|
||||
const primaryConfig = await initializeAgent(
|
||||
{
|
||||
req,
|
||||
res,
|
||||
loadTools,
|
||||
requestFiles: [],
|
||||
conversationId,
|
||||
parentMessageId,
|
||||
agent,
|
||||
endpointOption,
|
||||
allowedProviders,
|
||||
isInitialAgent: true,
|
||||
},
|
||||
{
|
||||
getConvoFiles,
|
||||
getFiles: db.getFiles,
|
||||
getUserKey: db.getUserKey,
|
||||
getMessages: db.getMessages,
|
||||
updateFilesUsage: db.updateFilesUsage,
|
||||
getUserKeyValues: db.getUserKeyValues,
|
||||
getUserCodeFiles: db.getUserCodeFiles,
|
||||
getToolFilesByIds: db.getToolFilesByIds,
|
||||
getCodeGeneratedFiles: db.getCodeGeneratedFiles,
|
||||
},
|
||||
);
|
||||
|
||||
// Determine if streaming is enabled (check both request and agent config)
|
||||
const streamingDisabled = !!primaryConfig.model_parameters?.disableStreaming;
|
||||
const actuallyStreaming = isStreaming && !streamingDisabled;
|
||||
|
||||
// Load previous messages if previous_response_id is provided
|
||||
let previousMessages = [];
|
||||
if (request.previous_response_id) {
|
||||
const userId = req.user?.id ?? 'api-user';
|
||||
previousMessages = await loadPreviousMessages(request.previous_response_id, userId);
|
||||
}
|
||||
|
||||
// Convert input to internal messages
|
||||
const inputMessages = convertToInternalMessages(
|
||||
typeof request.input === 'string' ? request.input : request.input,
|
||||
);
|
||||
|
||||
// Merge previous messages with new input
|
||||
const allMessages = [...previousMessages, ...inputMessages];
|
||||
|
||||
// Format for agent
|
||||
const toolSet = new Set((primaryConfig.tools ?? []).map((tool) => tool && tool.name));
|
||||
const { messages: formattedMessages, indexTokenCountMap } = formatAgentMessages(
|
||||
allMessages,
|
||||
{},
|
||||
toolSet,
|
||||
);
|
||||
|
||||
// Create tracker for streaming or aggregator for non-streaming
|
||||
const tracker = actuallyStreaming ? createResponseTracker() : null;
|
||||
const aggregator = actuallyStreaming ? null : createResponseAggregator();
|
||||
|
||||
// Set up response for streaming
|
||||
if (actuallyStreaming) {
|
||||
setupStreamingResponse(res);
|
||||
|
||||
// Create handler config
|
||||
const handlerConfig = {
|
||||
res,
|
||||
context,
|
||||
tracker,
|
||||
};
|
||||
|
||||
// Emit response.created then response.in_progress per Open Responses spec
|
||||
emitResponseCreated(handlerConfig);
|
||||
emitResponseInProgress(handlerConfig);
|
||||
|
||||
// Create event handlers
|
||||
const { handlers: responsesHandlers, finalizeStream } =
|
||||
createResponsesEventHandlers(handlerConfig);
|
||||
|
||||
// Built-in handler for processing raw model stream chunks
|
||||
const chatModelStreamHandler = new ChatModelStreamHandler();
|
||||
|
||||
// Artifact promises for processing tool outputs
|
||||
/** @type {Promise<import('librechat-data-provider').TAttachment | null>[]} */
|
||||
const artifactPromises = [];
|
||||
// Use Responses API-specific callback that emits librechat:attachment events
|
||||
const toolEndCallback = createResponsesToolEndCallback({
|
||||
req,
|
||||
res,
|
||||
tracker,
|
||||
artifactPromises,
|
||||
});
|
||||
|
||||
// Combine handlers
|
||||
const handlers = {
|
||||
on_chat_model_stream: {
|
||||
handle: async (event, data, metadata, graph) => {
|
||||
await chatModelStreamHandler.handle(event, data, metadata, graph);
|
||||
},
|
||||
},
|
||||
on_message_delta: responsesHandlers.on_message_delta,
|
||||
on_reasoning_delta: responsesHandlers.on_reasoning_delta,
|
||||
on_run_step: responsesHandlers.on_run_step,
|
||||
on_run_step_delta: responsesHandlers.on_run_step_delta,
|
||||
on_chat_model_end: responsesHandlers.on_chat_model_end,
|
||||
on_tool_end: new ToolEndHandler(toolEndCallback, logger),
|
||||
on_run_step_completed: { handle: () => {} },
|
||||
on_chain_stream: { handle: () => {} },
|
||||
on_chain_end: { handle: () => {} },
|
||||
on_agent_update: { handle: () => {} },
|
||||
on_custom_event: { handle: () => {} },
|
||||
};
|
||||
|
||||
// Create and run the agent
|
||||
const userId = req.user?.id ?? 'api-user';
|
||||
const userMCPAuthMap = primaryConfig.userMCPAuthMap;
|
||||
|
||||
const run = await createRun({
|
||||
agents: [primaryConfig],
|
||||
messages: formattedMessages,
|
||||
indexTokenCountMap,
|
||||
runId: responseId,
|
||||
signal: abortController.signal,
|
||||
customHandlers: handlers,
|
||||
requestBody: {
|
||||
messageId: responseId,
|
||||
conversationId,
|
||||
},
|
||||
user: { id: userId },
|
||||
});
|
||||
|
||||
if (!run) {
|
||||
throw new Error('Failed to create agent run');
|
||||
}
|
||||
|
||||
// Process the stream
|
||||
const config = {
|
||||
runName: 'AgentRun',
|
||||
configurable: {
|
||||
thread_id: conversationId,
|
||||
user_id: userId,
|
||||
user: createSafeUser(req.user),
|
||||
...(userMCPAuthMap != null && { userMCPAuthMap }),
|
||||
},
|
||||
signal: abortController.signal,
|
||||
streamMode: 'values',
|
||||
version: 'v2',
|
||||
};
|
||||
|
||||
await run.processStream({ messages: formattedMessages }, config, {
|
||||
callbacks: {
|
||||
[Callback.TOOL_ERROR]: (graph, error, toolId) => {
|
||||
logger.error(`[Responses API] Tool Error "${toolId}"`, error);
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
// Finalize the stream
|
||||
finalizeStream();
|
||||
res.end();
|
||||
|
||||
// Save to database if store: true
|
||||
if (request.store === true) {
|
||||
try {
|
||||
// Save conversation
|
||||
await saveConversation(req, conversationId, agentId, agent);
|
||||
|
||||
// Save input messages
|
||||
await saveInputMessages(req, conversationId, inputMessages, agentId);
|
||||
|
||||
// Build response for saving (use tracker with buildResponse for streaming)
|
||||
const finalResponse = buildResponse(context, tracker, 'completed');
|
||||
await saveResponseOutput(req, conversationId, responseId, finalResponse, agentId);
|
||||
|
||||
logger.debug(
|
||||
`[Responses API] Stored response ${responseId} in conversation ${conversationId}`,
|
||||
);
|
||||
} catch (saveError) {
|
||||
logger.error('[Responses API] Error saving response:', saveError);
|
||||
// Don't fail the request if saving fails
|
||||
}
|
||||
}
|
||||
|
||||
// Wait for artifact processing after response ends (non-blocking)
|
||||
if (artifactPromises.length > 0) {
|
||||
Promise.all(artifactPromises).catch((artifactError) => {
|
||||
logger.warn('[Responses API] Error processing artifacts:', artifactError);
|
||||
});
|
||||
}
|
||||
} else {
|
||||
// Non-streaming response
|
||||
const aggregatorHandlers = createAggregatorEventHandlers(aggregator);
|
||||
|
||||
// Built-in handler for processing raw model stream chunks
|
||||
const chatModelStreamHandler = new ChatModelStreamHandler();
|
||||
|
||||
// Artifact promises for processing tool outputs
|
||||
/** @type {Promise<import('librechat-data-provider').TAttachment | null>[]} */
|
||||
const artifactPromises = [];
|
||||
const toolEndCallback = createToolEndCallback({ req, res, artifactPromises, streamId: null });
|
||||
|
||||
// Combine handlers
|
||||
const handlers = {
|
||||
on_chat_model_stream: {
|
||||
handle: async (event, data, metadata, graph) => {
|
||||
await chatModelStreamHandler.handle(event, data, metadata, graph);
|
||||
},
|
||||
},
|
||||
on_message_delta: aggregatorHandlers.on_message_delta,
|
||||
on_reasoning_delta: aggregatorHandlers.on_reasoning_delta,
|
||||
on_run_step: aggregatorHandlers.on_run_step,
|
||||
on_run_step_delta: aggregatorHandlers.on_run_step_delta,
|
||||
on_chat_model_end: aggregatorHandlers.on_chat_model_end,
|
||||
on_tool_end: new ToolEndHandler(toolEndCallback, logger),
|
||||
on_run_step_completed: { handle: () => {} },
|
||||
on_chain_stream: { handle: () => {} },
|
||||
on_chain_end: { handle: () => {} },
|
||||
on_agent_update: { handle: () => {} },
|
||||
on_custom_event: { handle: () => {} },
|
||||
};
|
||||
|
||||
// Create and run the agent
|
||||
const userId = req.user?.id ?? 'api-user';
|
||||
const userMCPAuthMap = primaryConfig.userMCPAuthMap;
|
||||
|
||||
const run = await createRun({
|
||||
agents: [primaryConfig],
|
||||
messages: formattedMessages,
|
||||
indexTokenCountMap,
|
||||
runId: responseId,
|
||||
signal: abortController.signal,
|
||||
customHandlers: handlers,
|
||||
requestBody: {
|
||||
messageId: responseId,
|
||||
conversationId,
|
||||
},
|
||||
user: { id: userId },
|
||||
});
|
||||
|
||||
if (!run) {
|
||||
throw new Error('Failed to create agent run');
|
||||
}
|
||||
|
||||
// Process the stream
|
||||
const config = {
|
||||
runName: 'AgentRun',
|
||||
configurable: {
|
||||
thread_id: conversationId,
|
||||
user_id: userId,
|
||||
user: createSafeUser(req.user),
|
||||
...(userMCPAuthMap != null && { userMCPAuthMap }),
|
||||
},
|
||||
signal: abortController.signal,
|
||||
streamMode: 'values',
|
||||
version: 'v2',
|
||||
};
|
||||
|
||||
await run.processStream({ messages: formattedMessages }, config, {
|
||||
callbacks: {
|
||||
[Callback.TOOL_ERROR]: (graph, error, toolId) => {
|
||||
logger.error(`[Responses API] Tool Error "${toolId}"`, error);
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
// Wait for artifacts before sending response
|
||||
if (artifactPromises.length > 0) {
|
||||
try {
|
||||
await Promise.all(artifactPromises);
|
||||
} catch (artifactError) {
|
||||
logger.warn('[Responses API] Error processing artifacts:', artifactError);
|
||||
}
|
||||
}
|
||||
|
||||
// Build and send the response
|
||||
const response = buildAggregatedResponse(context, aggregator);
|
||||
|
||||
// Save to database if store: true
|
||||
if (request.store === true) {
|
||||
try {
|
||||
// Save conversation
|
||||
await saveConversation(req, conversationId, agentId, agent);
|
||||
|
||||
// Save input messages
|
||||
await saveInputMessages(req, conversationId, inputMessages, agentId);
|
||||
|
||||
// Save response output
|
||||
await saveResponseOutput(req, conversationId, responseId, response, agentId);
|
||||
|
||||
logger.debug(
|
||||
`[Responses API] Stored response ${responseId} in conversation ${conversationId}`,
|
||||
);
|
||||
} catch (saveError) {
|
||||
logger.error('[Responses API] Error saving response:', saveError);
|
||||
// Don't fail the request if saving fails
|
||||
}
|
||||
}
|
||||
|
||||
res.json(response);
|
||||
}
|
||||
} catch (error) {
|
||||
const errorMessage = error instanceof Error ? error.message : 'An error occurred';
|
||||
logger.error('[Responses API] Error:', error);
|
||||
|
||||
// Check if we already started streaming (headers sent)
|
||||
if (res.headersSent) {
|
||||
// Headers already sent, write error event and close
|
||||
writeDone(res);
|
||||
res.end();
|
||||
} else {
|
||||
sendResponsesErrorResponse(res, 500, errorMessage, 'server_error');
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* List available agents as models - GET /v1/models (also works with /v1/responses/models)
|
||||
*
|
||||
* Returns a list of available agents the user has remote access to.
|
||||
*
|
||||
* @param {import('express').Request} req
|
||||
* @param {import('express').Response} res
|
||||
*/
|
||||
const listModels = async (req, res) => {
|
||||
try {
|
||||
const userId = req.user?.id;
|
||||
const userRole = req.user?.role;
|
||||
|
||||
if (!userId) {
|
||||
return sendResponsesErrorResponse(res, 401, 'Authentication required', 'auth_error');
|
||||
}
|
||||
|
||||
// Find agents the user has remote access to (VIEW permission on REMOTE_AGENT)
|
||||
const accessibleAgentIds = await findAccessibleResources({
|
||||
userId,
|
||||
role: userRole,
|
||||
resourceType: ResourceType.REMOTE_AGENT,
|
||||
requiredPermissions: PermissionBits.VIEW,
|
||||
});
|
||||
|
||||
// Get the accessible agents
|
||||
let agents = [];
|
||||
if (accessibleAgentIds.length > 0) {
|
||||
agents = await getAgents({ _id: { $in: accessibleAgentIds } });
|
||||
}
|
||||
|
||||
// Convert to models format
|
||||
const models = agents.map((agent) => ({
|
||||
id: agent.id,
|
||||
object: 'model',
|
||||
created: Math.floor(new Date(agent.createdAt).getTime() / 1000),
|
||||
owned_by: agent.author ?? 'librechat',
|
||||
// Additional metadata
|
||||
name: agent.name,
|
||||
description: agent.description,
|
||||
provider: agent.provider,
|
||||
}));
|
||||
|
||||
res.json({
|
||||
object: 'list',
|
||||
data: models,
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('[Responses API] Error listing models:', error);
|
||||
sendResponsesErrorResponse(
|
||||
res,
|
||||
500,
|
||||
error instanceof Error ? error.message : 'Failed to list models',
|
||||
'server_error',
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Get Response - GET /v1/responses/:id
|
||||
*
|
||||
* Retrieves a stored response by its ID.
|
||||
* The response ID maps to a conversationId in LibreChat's storage.
|
||||
*
|
||||
* @param {import('express').Request} req
|
||||
* @param {import('express').Response} res
|
||||
*/
|
||||
const getResponse = async (req, res) => {
|
||||
try {
|
||||
const responseId = req.params.id;
|
||||
const userId = req.user?.id;
|
||||
|
||||
if (!responseId) {
|
||||
return sendResponsesErrorResponse(res, 400, 'Response ID is required');
|
||||
}
|
||||
|
||||
// The responseId could be either the response ID or the conversation ID
|
||||
// Try to find a conversation with this ID
|
||||
const conversation = await getConvo(userId, responseId);
|
||||
|
||||
if (!conversation) {
|
||||
return sendResponsesErrorResponse(
|
||||
res,
|
||||
404,
|
||||
`Response not found: ${responseId}`,
|
||||
'not_found',
|
||||
'response_not_found',
|
||||
);
|
||||
}
|
||||
|
||||
// Load messages for this conversation
|
||||
const messages = await db.getMessages({ conversationId: responseId, user: userId });
|
||||
|
||||
if (!messages || messages.length === 0) {
|
||||
return sendResponsesErrorResponse(
|
||||
res,
|
||||
404,
|
||||
`No messages found for response: ${responseId}`,
|
||||
'not_found',
|
||||
'response_not_found',
|
||||
);
|
||||
}
|
||||
|
||||
// Convert messages to Open Responses output format
|
||||
const output = convertMessagesToOutputItems(messages);
|
||||
|
||||
// Find the last assistant message for usage info
|
||||
const lastAssistantMessage = messages.filter((m) => !m.isCreatedByUser).pop();
|
||||
|
||||
// Build the response object
|
||||
const response = {
|
||||
id: responseId,
|
||||
object: 'response',
|
||||
created_at: Math.floor(new Date(conversation.createdAt || Date.now()).getTime() / 1000),
|
||||
completed_at: Math.floor(new Date(conversation.updatedAt || Date.now()).getTime() / 1000),
|
||||
status: 'completed',
|
||||
incomplete_details: null,
|
||||
model: conversation.agentId || conversation.model || 'unknown',
|
||||
previous_response_id: null,
|
||||
instructions: null,
|
||||
output,
|
||||
error: null,
|
||||
tools: [],
|
||||
tool_choice: 'auto',
|
||||
truncation: 'disabled',
|
||||
parallel_tool_calls: true,
|
||||
text: { format: { type: 'text' } },
|
||||
temperature: 1,
|
||||
top_p: 1,
|
||||
presence_penalty: 0,
|
||||
frequency_penalty: 0,
|
||||
top_logprobs: null,
|
||||
reasoning: null,
|
||||
user: userId,
|
||||
usage: lastAssistantMessage?.tokenCount
|
||||
? {
|
||||
input_tokens: 0,
|
||||
output_tokens: lastAssistantMessage.tokenCount,
|
||||
total_tokens: lastAssistantMessage.tokenCount,
|
||||
}
|
||||
: null,
|
||||
max_output_tokens: null,
|
||||
max_tool_calls: null,
|
||||
store: true,
|
||||
background: false,
|
||||
service_tier: 'default',
|
||||
metadata: {},
|
||||
safety_identifier: null,
|
||||
prompt_cache_key: null,
|
||||
};
|
||||
|
||||
res.json(response);
|
||||
} catch (error) {
|
||||
logger.error('[Responses API] Error getting response:', error);
|
||||
sendResponsesErrorResponse(
|
||||
res,
|
||||
500,
|
||||
error instanceof Error ? error.message : 'Failed to get response',
|
||||
'server_error',
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
module.exports = {
|
||||
createResponse,
|
||||
getResponse,
|
||||
listModels,
|
||||
setAppConfig,
|
||||
};
|
||||
|
|
@ -11,7 +11,9 @@ const {
|
|||
convertOcrToContextInPlace,
|
||||
} = require('@librechat/api');
|
||||
const {
|
||||
Time,
|
||||
Tools,
|
||||
CacheKeys,
|
||||
Constants,
|
||||
FileSources,
|
||||
ResourceType,
|
||||
|
|
@ -21,8 +23,6 @@ const {
|
|||
PermissionBits,
|
||||
actionDelimiter,
|
||||
removeNullishValues,
|
||||
CacheKeys,
|
||||
Time,
|
||||
} = require('librechat-data-provider');
|
||||
const {
|
||||
getListAgentsByAccess,
|
||||
|
|
@ -94,16 +94,25 @@ const createAgentHandler = async (req, res) => {
|
|||
|
||||
const agent = await createAgent(agentData);
|
||||
|
||||
// Automatically grant owner permissions to the creator
|
||||
try {
|
||||
await grantPermission({
|
||||
principalType: PrincipalType.USER,
|
||||
principalId: userId,
|
||||
resourceType: ResourceType.AGENT,
|
||||
resourceId: agent._id,
|
||||
accessRoleId: AccessRoleIds.AGENT_OWNER,
|
||||
grantedBy: userId,
|
||||
});
|
||||
await Promise.all([
|
||||
grantPermission({
|
||||
principalType: PrincipalType.USER,
|
||||
principalId: userId,
|
||||
resourceType: ResourceType.AGENT,
|
||||
resourceId: agent._id,
|
||||
accessRoleId: AccessRoleIds.AGENT_OWNER,
|
||||
grantedBy: userId,
|
||||
}),
|
||||
grantPermission({
|
||||
principalType: PrincipalType.USER,
|
||||
principalId: userId,
|
||||
resourceType: ResourceType.REMOTE_AGENT,
|
||||
resourceId: agent._id,
|
||||
accessRoleId: AccessRoleIds.REMOTE_AGENT_OWNER,
|
||||
grantedBy: userId,
|
||||
}),
|
||||
]);
|
||||
logger.debug(
|
||||
`[createAgent] Granted owner permissions to user ${userId} for agent ${agent.id}`,
|
||||
);
|
||||
|
|
@ -396,16 +405,25 @@ const duplicateAgentHandler = async (req, res) => {
|
|||
newAgentData.actions = agentActions;
|
||||
const newAgent = await createAgent(newAgentData);
|
||||
|
||||
// Automatically grant owner permissions to the duplicator
|
||||
try {
|
||||
await grantPermission({
|
||||
principalType: PrincipalType.USER,
|
||||
principalId: userId,
|
||||
resourceType: ResourceType.AGENT,
|
||||
resourceId: newAgent._id,
|
||||
accessRoleId: AccessRoleIds.AGENT_OWNER,
|
||||
grantedBy: userId,
|
||||
});
|
||||
await Promise.all([
|
||||
grantPermission({
|
||||
principalType: PrincipalType.USER,
|
||||
principalId: userId,
|
||||
resourceType: ResourceType.AGENT,
|
||||
resourceId: newAgent._id,
|
||||
accessRoleId: AccessRoleIds.AGENT_OWNER,
|
||||
grantedBy: userId,
|
||||
}),
|
||||
grantPermission({
|
||||
principalType: PrincipalType.USER,
|
||||
principalId: userId,
|
||||
resourceType: ResourceType.REMOTE_AGENT,
|
||||
resourceId: newAgent._id,
|
||||
accessRoleId: AccessRoleIds.REMOTE_AGENT_OWNER,
|
||||
grantedBy: userId,
|
||||
}),
|
||||
]);
|
||||
logger.debug(
|
||||
`[duplicateAgent] Granted owner permissions to user ${userId} for duplicated agent ${newAgent.id}`,
|
||||
);
|
||||
|
|
|
|||
|
|
@ -299,6 +299,7 @@ if (cluster.isMaster) {
|
|||
app.use('/api/auth', routes.auth);
|
||||
app.use('/api/actions', routes.actions);
|
||||
app.use('/api/keys', routes.keys);
|
||||
app.use('/api/api-keys', routes.apiKeys);
|
||||
app.use('/api/user', routes.user);
|
||||
app.use('/api/search', routes.search);
|
||||
app.use('/api/messages', routes.messages);
|
||||
|
|
|
|||
|
|
@ -137,6 +137,7 @@ const startServer = async () => {
|
|||
app.use('/api/admin', routes.adminAuth);
|
||||
app.use('/api/actions', routes.actions);
|
||||
app.use('/api/keys', routes.keys);
|
||||
app.use('/api/api-keys', routes.apiKeys);
|
||||
app.use('/api/user', routes.user);
|
||||
app.use('/api/search', routes.search);
|
||||
app.use('/api/messages', routes.messages);
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@ const resourceToPermissionType = {
|
|||
[ResourceType.AGENT]: PermissionTypes.AGENTS,
|
||||
[ResourceType.PROMPTGROUP]: PermissionTypes.PROMPTS,
|
||||
[ResourceType.MCPSERVER]: PermissionTypes.MCP_SERVERS,
|
||||
[ResourceType.REMOTE_AGENT]: PermissionTypes.REMOTE_AGENTS,
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -53,6 +53,12 @@ const checkResourcePermissionAccess = (requiredPermission) => (req, res, next) =
|
|||
requiredPermission,
|
||||
resourceIdParam: 'resourceId',
|
||||
});
|
||||
} else if (resourceType === ResourceType.REMOTE_AGENT) {
|
||||
middleware = canAccessResource({
|
||||
resourceType: ResourceType.REMOTE_AGENT,
|
||||
requiredPermission,
|
||||
resourceIdParam: 'resourceId',
|
||||
});
|
||||
} else if (resourceType === ResourceType.PROMPTGROUP) {
|
||||
middleware = canAccessResource({
|
||||
resourceType: ResourceType.PROMPTGROUP,
|
||||
|
|
|
|||
|
|
@ -26,10 +26,12 @@ const mockGenerationJobManager = {
|
|||
const mockSaveMessage = jest.fn();
|
||||
|
||||
jest.mock('@librechat/data-schemas', () => ({
|
||||
...jest.requireActual('@librechat/data-schemas'),
|
||||
logger: mockLogger,
|
||||
}));
|
||||
|
||||
jest.mock('@librechat/api', () => ({
|
||||
...jest.requireActual('@librechat/api'),
|
||||
isEnabled: jest.fn().mockReturnValue(false),
|
||||
GenerationJobManager: mockGenerationJobManager,
|
||||
}));
|
||||
|
|
|
|||
1125
api/server/routes/agents/__tests__/responses.spec.js
Normal file
1125
api/server/routes/agents/__tests__/responses.spec.js
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -10,6 +10,8 @@ const {
|
|||
messageUserLimiter,
|
||||
} = require('~/server/middleware');
|
||||
const { saveMessage } = require('~/models');
|
||||
const openai = require('./openai');
|
||||
const responses = require('./responses');
|
||||
const { v1 } = require('./v1');
|
||||
const chat = require('./chat');
|
||||
|
||||
|
|
@ -17,6 +19,20 @@ const { LIMIT_MESSAGE_IP, LIMIT_MESSAGE_USER } = process.env ?? {};
|
|||
|
||||
const router = express.Router();
|
||||
|
||||
/**
|
||||
* Open Responses API routes (API key authentication handled in route file)
|
||||
* Mounted at /agents/v1/responses (full path: /api/agents/v1/responses)
|
||||
* NOTE: Must be mounted BEFORE /v1 to avoid being caught by the less specific route
|
||||
* @see https://openresponses.org/specification
|
||||
*/
|
||||
router.use('/v1/responses', responses);
|
||||
|
||||
/**
|
||||
* OpenAI-compatible API routes (API key authentication handled in route file)
|
||||
* Mounted at /agents/v1 (full path: /api/agents/v1/chat/completions)
|
||||
*/
|
||||
router.use('/v1', openai);
|
||||
|
||||
router.use(requireJwtAuth);
|
||||
router.use(checkBan);
|
||||
router.use(uaParser);
|
||||
|
|
|
|||
110
api/server/routes/agents/openai.js
Normal file
110
api/server/routes/agents/openai.js
Normal file
|
|
@ -0,0 +1,110 @@
|
|||
/**
|
||||
* OpenAI-compatible API routes for LibreChat agents.
|
||||
*
|
||||
* Provides a /v1/chat/completions compatible interface for
|
||||
* interacting with LibreChat agents remotely via API.
|
||||
*
|
||||
* Usage:
|
||||
* POST /v1/chat/completions - Chat with an agent
|
||||
* GET /v1/models - List available agents
|
||||
* GET /v1/models/:model - Get agent details
|
||||
*
|
||||
* Request format:
|
||||
* {
|
||||
* "model": "agent_id_here",
|
||||
* "messages": [{"role": "user", "content": "Hello!"}],
|
||||
* "stream": true
|
||||
* }
|
||||
*/
|
||||
const express = require('express');
|
||||
const { PermissionTypes, Permissions } = require('librechat-data-provider');
|
||||
const {
|
||||
generateCheckAccess,
|
||||
createRequireApiKeyAuth,
|
||||
createCheckRemoteAgentAccess,
|
||||
} = require('@librechat/api');
|
||||
const {
|
||||
OpenAIChatCompletionController,
|
||||
ListModelsController,
|
||||
GetModelController,
|
||||
} = require('~/server/controllers/agents/openai');
|
||||
const { getEffectivePermissions } = require('~/server/services/PermissionService');
|
||||
const { validateAgentApiKey, findUser } = require('~/models');
|
||||
const { configMiddleware } = require('~/server/middleware');
|
||||
const { getRoleByName } = require('~/models/Role');
|
||||
const { getAgent } = require('~/models/Agent');
|
||||
|
||||
const router = express.Router();
|
||||
|
||||
const requireApiKeyAuth = createRequireApiKeyAuth({
|
||||
validateAgentApiKey,
|
||||
findUser,
|
||||
});
|
||||
|
||||
const checkRemoteAgentsFeature = generateCheckAccess({
|
||||
permissionType: PermissionTypes.REMOTE_AGENTS,
|
||||
permissions: [Permissions.USE],
|
||||
getRoleByName,
|
||||
});
|
||||
|
||||
const checkAgentPermission = createCheckRemoteAgentAccess({
|
||||
getAgent,
|
||||
getEffectivePermissions,
|
||||
});
|
||||
|
||||
router.use(requireApiKeyAuth);
|
||||
router.use(configMiddleware);
|
||||
router.use(checkRemoteAgentsFeature);
|
||||
|
||||
/**
|
||||
* @route POST /v1/chat/completions
|
||||
* @desc OpenAI-compatible chat completions with agents
|
||||
* @access Private (API key auth required)
|
||||
*
|
||||
* Request body:
|
||||
* {
|
||||
* "model": "agent_id", // Required: The agent ID to use
|
||||
* "messages": [...], // Required: Array of chat messages
|
||||
* "stream": true, // Optional: Whether to stream (default: false)
|
||||
* "conversation_id": "...", // Optional: Conversation ID for context
|
||||
* "parent_message_id": "..." // Optional: Parent message for threading
|
||||
* }
|
||||
*
|
||||
* Response (streaming):
|
||||
* - SSE stream with OpenAI chat.completion.chunk format
|
||||
* - Includes delta.reasoning for thinking/reasoning content
|
||||
*
|
||||
* Response (non-streaming):
|
||||
* - Standard OpenAI chat.completion format
|
||||
*/
|
||||
router.post('/chat/completions', checkAgentPermission, OpenAIChatCompletionController);
|
||||
|
||||
/**
|
||||
* @route GET /v1/models
|
||||
* @desc List available agents as models
|
||||
* @access Private (API key auth required)
|
||||
*
|
||||
* Response:
|
||||
* {
|
||||
* "object": "list",
|
||||
* "data": [
|
||||
* {
|
||||
* "id": "agent_id",
|
||||
* "object": "model",
|
||||
* "name": "Agent Name",
|
||||
* "provider": "openai",
|
||||
* ...
|
||||
* }
|
||||
* ]
|
||||
* }
|
||||
*/
|
||||
router.get('/models', ListModelsController);
|
||||
|
||||
/**
|
||||
* @route GET /v1/models/:model
|
||||
* @desc Get details for a specific agent/model
|
||||
* @access Private (API key auth required)
|
||||
*/
|
||||
router.get('/models/:model', GetModelController);
|
||||
|
||||
module.exports = router;
|
||||
144
api/server/routes/agents/responses.js
Normal file
144
api/server/routes/agents/responses.js
Normal file
|
|
@ -0,0 +1,144 @@
|
|||
/**
|
||||
* Open Responses API routes for LibreChat agents.
|
||||
*
|
||||
* Implements the Open Responses specification for a forward-looking,
|
||||
* agentic API that uses items as the fundamental unit and semantic
|
||||
* streaming events.
|
||||
*
|
||||
* Usage:
|
||||
* POST /v1/responses - Create a response
|
||||
* GET /v1/models - List available agents
|
||||
*
|
||||
* Request format:
|
||||
* {
|
||||
* "model": "agent_id_here",
|
||||
* "input": "Hello!" or [{ type: "message", role: "user", content: "Hello!" }],
|
||||
* "stream": true,
|
||||
* "previous_response_id": "optional_conversation_id"
|
||||
* }
|
||||
*
|
||||
* @see https://openresponses.org/specification
|
||||
*/
|
||||
const express = require('express');
|
||||
const { PermissionTypes, Permissions } = require('librechat-data-provider');
|
||||
const {
|
||||
generateCheckAccess,
|
||||
createRequireApiKeyAuth,
|
||||
createCheckRemoteAgentAccess,
|
||||
} = require('@librechat/api');
|
||||
const {
|
||||
createResponse,
|
||||
getResponse,
|
||||
listModels,
|
||||
} = require('~/server/controllers/agents/responses');
|
||||
const { getEffectivePermissions } = require('~/server/services/PermissionService');
|
||||
const { validateAgentApiKey, findUser } = require('~/models');
|
||||
const { configMiddleware } = require('~/server/middleware');
|
||||
const { getRoleByName } = require('~/models/Role');
|
||||
const { getAgent } = require('~/models/Agent');
|
||||
|
||||
const router = express.Router();
|
||||
|
||||
const requireApiKeyAuth = createRequireApiKeyAuth({
|
||||
validateAgentApiKey,
|
||||
findUser,
|
||||
});
|
||||
|
||||
const checkRemoteAgentsFeature = generateCheckAccess({
|
||||
permissionType: PermissionTypes.REMOTE_AGENTS,
|
||||
permissions: [Permissions.USE],
|
||||
getRoleByName,
|
||||
});
|
||||
|
||||
const checkAgentPermission = createCheckRemoteAgentAccess({
|
||||
getAgent,
|
||||
getEffectivePermissions,
|
||||
});
|
||||
|
||||
router.use(requireApiKeyAuth);
|
||||
router.use(configMiddleware);
|
||||
router.use(checkRemoteAgentsFeature);
|
||||
|
||||
/**
|
||||
* @route POST /v1/responses
|
||||
* @desc Create a model response following Open Responses specification
|
||||
* @access Private (API key auth required)
|
||||
*
|
||||
* Request body:
|
||||
* {
|
||||
* "model": "agent_id", // Required: The agent ID to use
|
||||
* "input": "..." | [...], // Required: String or array of input items
|
||||
* "stream": true, // Optional: Whether to stream (default: false)
|
||||
* "previous_response_id": "...", // Optional: Previous response for continuation
|
||||
* "instructions": "...", // Optional: Additional instructions
|
||||
* "tools": [...], // Optional: Additional tools
|
||||
* "tool_choice": "auto", // Optional: Tool choice mode
|
||||
* "max_output_tokens": 4096, // Optional: Max tokens
|
||||
* "temperature": 0.7 // Optional: Temperature
|
||||
* }
|
||||
*
|
||||
* Response (streaming):
|
||||
* - SSE stream with semantic events:
|
||||
* - response.in_progress
|
||||
* - response.output_item.added
|
||||
* - response.content_part.added
|
||||
* - response.output_text.delta
|
||||
* - response.output_text.done
|
||||
* - response.function_call_arguments.delta
|
||||
* - response.output_item.done
|
||||
* - response.completed
|
||||
* - [DONE]
|
||||
*
|
||||
* Response (non-streaming):
|
||||
* {
|
||||
* "id": "resp_xxx",
|
||||
* "object": "response",
|
||||
* "created_at": 1234567890,
|
||||
* "status": "completed",
|
||||
* "model": "agent_id",
|
||||
* "output": [...], // Array of output items
|
||||
* "usage": { ... }
|
||||
* }
|
||||
*/
|
||||
router.post('/', checkAgentPermission, createResponse);
|
||||
|
||||
/**
|
||||
* @route GET /v1/responses/models
|
||||
* @desc List available agents as models
|
||||
* @access Private (API key auth required)
|
||||
*
|
||||
* Response:
|
||||
* {
|
||||
* "object": "list",
|
||||
* "data": [
|
||||
* {
|
||||
* "id": "agent_id",
|
||||
* "object": "model",
|
||||
* "name": "Agent Name",
|
||||
* "provider": "openai",
|
||||
* ...
|
||||
* }
|
||||
* ]
|
||||
* }
|
||||
*/
|
||||
router.get('/models', listModels);
|
||||
|
||||
/**
|
||||
* @route GET /v1/responses/:id
|
||||
* @desc Retrieve a stored response by ID
|
||||
* @access Private (API key auth required)
|
||||
*
|
||||
* Response:
|
||||
* {
|
||||
* "id": "resp_xxx",
|
||||
* "object": "response",
|
||||
* "created_at": 1234567890,
|
||||
* "status": "completed",
|
||||
* "model": "agent_id",
|
||||
* "output": [...],
|
||||
* "usage": { ... }
|
||||
* }
|
||||
*/
|
||||
router.get('/:id', getResponse);
|
||||
|
||||
module.exports = router;
|
||||
36
api/server/routes/apiKeys.js
Normal file
36
api/server/routes/apiKeys.js
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
const express = require('express');
|
||||
const { generateCheckAccess, createApiKeyHandlers } = require('@librechat/api');
|
||||
const { PermissionTypes, Permissions } = require('librechat-data-provider');
|
||||
const {
|
||||
getAgentApiKeyById,
|
||||
createAgentApiKey,
|
||||
deleteAgentApiKey,
|
||||
listAgentApiKeys,
|
||||
} = require('~/models');
|
||||
const { requireJwtAuth } = require('~/server/middleware');
|
||||
const { getRoleByName } = require('~/models/Role');
|
||||
|
||||
const router = express.Router();
|
||||
|
||||
const handlers = createApiKeyHandlers({
|
||||
createAgentApiKey,
|
||||
listAgentApiKeys,
|
||||
deleteAgentApiKey,
|
||||
getAgentApiKeyById,
|
||||
});
|
||||
|
||||
const checkRemoteAgentsUse = generateCheckAccess({
|
||||
permissionType: PermissionTypes.REMOTE_AGENTS,
|
||||
permissions: [Permissions.USE],
|
||||
getRoleByName,
|
||||
});
|
||||
|
||||
router.post('/', requireJwtAuth, checkRemoteAgentsUse, handlers.createApiKey);
|
||||
|
||||
router.get('/', requireJwtAuth, checkRemoteAgentsUse, handlers.listApiKeys);
|
||||
|
||||
router.get('/:id', requireJwtAuth, checkRemoteAgentsUse, handlers.getApiKey);
|
||||
|
||||
router.delete('/:id', requireJwtAuth, checkRemoteAgentsUse, handlers.deleteApiKey);
|
||||
|
||||
module.exports = router;
|
||||
|
|
@ -10,6 +10,7 @@ const presets = require('./presets');
|
|||
const prompts = require('./prompts');
|
||||
const balance = require('./balance');
|
||||
const actions = require('./actions');
|
||||
const apiKeys = require('./apiKeys');
|
||||
const banner = require('./banner');
|
||||
const search = require('./search');
|
||||
const models = require('./models');
|
||||
|
|
@ -31,6 +32,7 @@ module.exports = {
|
|||
auth,
|
||||
adminAuth,
|
||||
keys,
|
||||
apiKeys,
|
||||
user,
|
||||
tags,
|
||||
roles,
|
||||
|
|
|
|||
|
|
@ -6,9 +6,10 @@ const {
|
|||
agentPermissionsSchema,
|
||||
promptPermissionsSchema,
|
||||
memoryPermissionsSchema,
|
||||
mcpServersPermissionsSchema,
|
||||
marketplacePermissionsSchema,
|
||||
peoplePickerPermissionsSchema,
|
||||
mcpServersPermissionsSchema,
|
||||
remoteAgentsPermissionsSchema,
|
||||
} = require('librechat-data-provider');
|
||||
const { checkAdmin, requireJwtAuth } = require('~/server/middleware');
|
||||
const { updateRoleByName, getRoleByName } = require('~/models/Role');
|
||||
|
|
@ -51,6 +52,11 @@ const permissionConfigs = {
|
|||
permissionType: PermissionTypes.MARKETPLACE,
|
||||
errorMessage: 'Invalid marketplace permissions.',
|
||||
},
|
||||
'remote-agents': {
|
||||
schema: remoteAgentsPermissionsSchema,
|
||||
permissionType: PermissionTypes.REMOTE_AGENTS,
|
||||
errorMessage: 'Invalid remote agents permissions.',
|
||||
},
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -160,4 +166,10 @@ router.put('/:roleName/mcp-servers', checkAdmin, createPermissionUpdateHandler('
|
|||
*/
|
||||
router.put('/:roleName/marketplace', checkAdmin, createPermissionUpdateHandler('marketplace'));
|
||||
|
||||
/**
|
||||
* PUT /api/roles/:roleName/remote-agents
|
||||
* Update remote agents (API) permissions for a specific role
|
||||
*/
|
||||
router.put('/:roleName/remote-agents', checkAdmin, createPermissionUpdateHandler('remote-agents'));
|
||||
|
||||
module.exports = router;
|
||||
|
|
|
|||
|
|
@ -141,7 +141,6 @@ const checkPermission = async ({ userId, role, resourceType, resourceId, require
|
|||
|
||||
validateResourceType(resourceType);
|
||||
|
||||
// Get all principals for the user (user + groups + public)
|
||||
const principals = await getUserPrincipals({ userId, role });
|
||||
|
||||
if (principals.length === 0) {
|
||||
|
|
@ -151,7 +150,6 @@ const checkPermission = async ({ userId, role, resourceType, resourceId, require
|
|||
return await hasPermission(principals, resourceType, resourceId, requiredPermission);
|
||||
} catch (error) {
|
||||
logger.error(`[PermissionService.checkPermission] Error: ${error.message}`);
|
||||
// Re-throw validation errors
|
||||
if (error.message.includes('requiredPermission must be')) {
|
||||
throw error;
|
||||
}
|
||||
|
|
@ -172,12 +170,12 @@ const getEffectivePermissions = async ({ userId, role, resourceType, resourceId
|
|||
try {
|
||||
validateResourceType(resourceType);
|
||||
|
||||
// Get all principals for the user (user + groups + public)
|
||||
const principals = await getUserPrincipals({ userId, role });
|
||||
|
||||
if (principals.length === 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return await getEffectivePermissionsACL(principals, resourceType, resourceId);
|
||||
} catch (error) {
|
||||
logger.error(`[PermissionService.getEffectivePermissions] Error: ${error.message}`);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue