mirror of
https://github.com/hanzoai/chat.git
synced 2026-09-30 20:51:17 +00:00
Danny Avila
b4d4533971
* chore: move database model methods to /packages/data-schemas * chore: add TypeScript ESLint rule to warn on unused variables * refactor: model imports to streamline access - Consolidated model imports across various files to improve code organization and reduce redundancy. - Updated imports for models such as Assistant, Message, Conversation, and others to a unified import path. - Adjusted middleware and service files to reflect the new import structure, ensuring functionality remains intact. - Enhanced test files to align with the new import paths, maintaining test coverage and integrity. * chore: migrate database models to packages/data-schemas and refactor all direct Mongoose Model usage outside of data-schemas * test: update agent model mocks in unit tests - Added `getAgent` mock to `client.test.js` to enhance test coverage for agent-related functionality. - Removed redundant `getAgent` and `getAgents` mocks from `openai.spec.js` and `responses.unit.spec.js` to streamline test setup and reduce duplication. - Ensured consistency in agent mock implementations across test files. * fix: update types in data-schemas * refactor: enhance type definitions in transaction and spending methods - Updated type definitions in `checkBalance.ts` to use specific request and response types. - Refined `spendTokens.ts` to utilize a new `SpendTxData` interface for better clarity and type safety. - Improved transaction handling in `transaction.ts` by introducing `TransactionResult` and `TxData` interfaces, ensuring consistent data structures across methods. - Adjusted unit tests in `transaction.spec.ts` to accommodate new type definitions and enhance robustness. * refactor: streamline model imports and enhance code organization - Consolidated model imports across various controllers and services to a unified import path, improving code clarity and reducing redundancy. - Updated multiple files to reflect the new import structure, ensuring all functionalities remain intact. - Enhanced overall code organization by removing duplicate import statements and optimizing the usage of model methods. * feat: implement loadAddedAgent and refactor agent loading logic - Introduced `loadAddedAgent` function to handle loading agents from added conversations, supporting multi-convo parallel execution. - Created a new `load.ts` file to encapsulate agent loading functionalities, including `loadEphemeralAgent` and `loadAgent`. - Updated the `index.ts` file to export the new `load` module instead of the deprecated `loadAgent`. - Enhanced type definitions and improved error handling in the agent loading process. - Adjusted unit tests to reflect changes in the agent loading structure and ensure comprehensive coverage. * refactor: enhance balance handling with new update interface - Introduced `IBalanceUpdate` interface to streamline balance update operations across the codebase. - Updated `upsertBalanceFields` method signatures in `balance.ts`, `transaction.ts`, and related tests to utilize the new interface for improved type safety. - Adjusted type imports in `balance.spec.ts` to include `IBalanceUpdate`, ensuring consistency in balance management functionalities. - Enhanced overall code clarity and maintainability by refining type definitions related to balance operations. * feat: add unit tests for loadAgent functionality and enhance agent loading logic - Introduced comprehensive unit tests for the `loadAgent` function, covering various scenarios including null and empty agent IDs, loading of ephemeral agents, and permission checks. - Enhanced the `initializeClient` function by moving `getConvoFiles` to the correct position in the database method exports, ensuring proper functionality. - Improved test coverage for agent loading, including handling of non-existent agents and user permissions. * chore: reorder memory method exports for consistency - Moved `deleteAllUserMemories` to the correct position in the exported memory methods, ensuring a consistent and logical order of method exports in `memory.ts`.
97 lines
2.8 KiB
JavaScript
97 lines
2.8 KiB
JavaScript
const { ToolCall } = require('~/db/models');
|
|
|
|
/**
|
|
* Create a new tool call
|
|
* @param {IToolCallData} toolCallData - The tool call data
|
|
* @returns {Promise<IToolCallData>} The created tool call document
|
|
*/
|
|
async function createToolCall(toolCallData) {
|
|
try {
|
|
return await ToolCall.create(toolCallData);
|
|
} catch (error) {
|
|
throw new Error(`Error creating tool call: ${error.message}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get a tool call by ID
|
|
* @param {string} id - The tool call document ID
|
|
* @returns {Promise<IToolCallData|null>} The tool call document or null if not found
|
|
*/
|
|
async function getToolCallById(id) {
|
|
try {
|
|
return await ToolCall.findById(id).lean();
|
|
} catch (error) {
|
|
throw new Error(`Error fetching tool call: ${error.message}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get tool calls by message ID and user
|
|
* @param {string} messageId - The message ID
|
|
* @param {string} userId - The user's ObjectId
|
|
* @returns {Promise<Array>} Array of tool call documents
|
|
*/
|
|
async function getToolCallsByMessage(messageId, userId) {
|
|
try {
|
|
return await ToolCall.find({ messageId, user: userId }).lean();
|
|
} catch (error) {
|
|
throw new Error(`Error fetching tool calls: ${error.message}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get tool calls by conversation ID and user
|
|
* @param {string} conversationId - The conversation ID
|
|
* @param {string} userId - The user's ObjectId
|
|
* @returns {Promise<IToolCallData[]>} Array of tool call documents
|
|
*/
|
|
async function getToolCallsByConvo(conversationId, userId) {
|
|
try {
|
|
return await ToolCall.find({ conversationId, user: userId }).lean();
|
|
} catch (error) {
|
|
throw new Error(`Error fetching tool calls: ${error.message}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update a tool call
|
|
* @param {string} id - The tool call document ID
|
|
* @param {Partial<IToolCallData>} updateData - The data to update
|
|
* @returns {Promise<IToolCallData|null>} The updated tool call document or null if not found
|
|
*/
|
|
async function updateToolCall(id, updateData) {
|
|
try {
|
|
return await ToolCall.findByIdAndUpdate(id, updateData, { new: true }).lean();
|
|
} catch (error) {
|
|
throw new Error(`Error updating tool call: ${error.message}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delete a tool call
|
|
* @param {string} userId - The related user's ObjectId
|
|
* @param {string} [conversationId] - The tool call conversation ID
|
|
* @returns {Promise<{ ok?: number; n?: number; deletedCount?: number }>} The result of the delete operation
|
|
*/
|
|
async function deleteToolCalls(userId, conversationId) {
|
|
try {
|
|
const query = { user: userId };
|
|
if (conversationId) {
|
|
query.conversationId = conversationId;
|
|
}
|
|
return await ToolCall.deleteMany(query);
|
|
} catch (error) {
|
|
throw new Error(`Error deleting tool call: ${error.message}`);
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
createToolCall,
|
|
updateToolCall,
|
|
deleteToolCalls,
|
|
getToolCallById,
|
|
getToolCallsByConvo,
|
|
getToolCallsByMessage,
|
|
};
|