Open Source Wealth Management Software. Angular + NestJS + Prisma + Nx + TypeScript 🤍
TypeScript angularetffinancefintechghostfoliohacktoberfestinvestingnestjsosspersonal-financeportfolioprismasoftwarestocktrackertradingtypescriptwealth-managementweb
import { McpService } from '@ghostfolio/api/app/endpoints/mcp/mcp.service';
import { CallerFacingError } from '@ghostfolio/api/errors/caller-facing.error';
import { encodeDataSource } from '@ghostfolio/api/helper/data-source.helper';
import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
import { PortfolioTableService } from '@ghostfolio/api/services/portfolio-table/portfolio-table.service';
import { PropertyService } from '@ghostfolio/api/services/property/property.service';
import {
DEFAULT_LOCALE,
PROPERTY_API_KEY_OPENROUTER,
PROPERTY_OPENROUTER_MODEL,
PROPERTY_OPENROUTER_MODEL_AGENT,
PROPERTY_OPENROUTER_MODEL_VISION
} from '@ghostfolio/common/config';
import { isValidCustomAssetProfileSymbol } from '@ghostfolio/common/helper';
import type { UserWithSettings } from '@ghostfolio/common/types';
import { Logger } from '@nestjs/common';
import { createOpenRouter } from '@openrouter/ai-sdk-provider';
import { DataSource, Type as ActivityType } from '@prisma/client';
import { generateText, NoObjectGeneratedError } from 'ai';
import { z } from 'zod';
import { ACTIVITY_ROWS_OUTPUT, ROW_MATCHES_OUTPUT } from './ai.schemas';
import { AiService } from './ai.service';
import { createActivityRow } from './ai.test-utils';
import { AccountHint } from './types/account-hint.type';
import { AccountToMatch } from './types/account-to-match.type';
import { ActivityRow } from './types/activity-row.type';
// The packages are ECMAScript modules, which Jest cannot load
jest.mock('@openrouter/ai-sdk-provider', () => {
return { createOpenRouter: jest.fn() };
});
jest.mock('ai', () => {
return {
generateText: jest.fn(),
NoObjectGeneratedError: class MockNoObjectGeneratedError extends Error {
public readonly finishReason: string;
public readonly response?: { modelId: string };
public readonly usage?: { totalTokens: number };
public constructor({
finishReason,
response,
usage
}: {
finishReason: string;
response?: { modelId: string };
usage?: { totalTokens: number };
}) {
super('No object generated');
this.finishReason = finishReason;
this.response = response;
this.usage = usage;
}
public static isInstance(error: unknown) {
return error instanceof MockNoObjectGeneratedError;
}
},
Output: {
object: jest.fn((options: unknown) => {
return options;
})
}
};
});
describe('AiService', () => {
const abortSignal = new AbortController().signal;
const model = { modelId: 'model' };
const rows: ActivityRow[] = [
createActivityRow({ accountName: null, symbol: null })
];
let aiService: AiService;
let chat: jest.Mock;
let dataProviderService: DataProviderService;
let mcpService: McpService;
let properties: Record<string, string>;
beforeEach(() => {
jest.clearAllMocks();
jest.spyOn(Logger.prototype, 'log').mockImplementation();
chat = jest.fn().mockReturnValue(model);
jest
.mocked(createOpenRouter)
.mockReturnValue({ chat } as unknown as ReturnType<
typeof createOpenRouter
>);
jest.mocked(generateText).mockResolvedValue({
output: { broker: 'Swissquote', rows },
steps: [{}],
totalUsage: { totalTokens: 1000 }
} as unknown as Awaited<ReturnType<typeof generateText>>);
properties = {
[PROPERTY_API_KEY_OPENROUTER]: 'api-key',
[PROPERTY_OPENROUTER_MODEL]: 'general-model',
[PROPERTY_OPENROUTER_MODEL_AGENT]: 'agent-model',
[PROPERTY_OPENROUTER_MODEL_VISION]: 'vision-model'
};
dataProviderService = {
getDataSources: jest
.fn()
.mockResolvedValue([DataSource.MANUAL, DataSource.YAHOO])
} as unknown as DataProviderService;
mcpService = {
getAccounts: jest.fn().mockResolvedValue({
content: [{ text: '## Accounts', type: 'text' }]
}),
getAssetProfilesOfUser: jest.fn().mockResolvedValue([]),
searchAssetProfiles: jest.fn().mockResolvedValue({
content: [{ text: '{ "assetProfiles": [] }', type: 'text' }]
})
} as unknown as McpService;
const propertyService = {
getByKey: jest.fn().mockImplementation((key: string) => {
return Promise.resolve(properties[key]);
})
} as unknown as PropertyService;
aiService = new AiService(
{ get: jest.fn() } as unknown as ConfigurationService,
dataProviderService,
mcpService,
{} as PortfolioTableService,
propertyService
);
});
describe('getActivityRowsFromFile', () => {
it('Passes a PDF file as a file part to the vision model and gives the rows', async () => {
const buffer = Buffer.from('%PDF-1.7');
await expect(
aiService.getActivityRowsFromFile({
abortSignal,
file: { buffer, mediaType: 'application/pdf' },
locale: 'de-CH'
})
).resolves.toEqual({ broker: 'Swissquote', rows });
expect(createOpenRouter).toHaveBeenCalledWith({ apiKey: 'api-key' });
expect(generateText).toHaveBeenCalledWith(
expect.objectContaining({
abortSignal,
messages: [
{
content: [
{ data: buffer, mediaType: 'application/pdf', type: 'file' }
],
role: 'user'
}
],
model,
output: { schema: ACTIVITY_ROWS_OUTPUT }
})
);
});
it('Passes the name of the file as text before the file and gives the broker', async () => {
const buffer = Buffer.from('%PDF-1.7');
await expect(
aiService.getActivityRowsFromFile({
file: {
buffer,
mediaType: 'application/pdf',
name: 'swissquote-2022.pdf'
},
locale: 'de-CH'
})
).resolves.toEqual({ broker: 'Swissquote', rows });
expect(generateText).toHaveBeenCalledWith(
expect.objectContaining({
messages: [
{
content: [
{ text: 'File name: swissquote-2022.pdf', type: 'text' },
{ data: buffer, mediaType: 'application/pdf', type: 'file' }
],
role: 'user'
}
]
})
);
});
it('Passes a CSV file as text', async () => {
const csv = 'Date;Type;ISIN\n15.01.2026;Kauf;US0378331005';
await aiService.getActivityRowsFromFile({
file: { buffer: Buffer.from(csv), mediaType: 'text/csv' },
locale: 'de-CH'
});
expect(generateText).toHaveBeenCalledWith(
expect.objectContaining({
messages: [{ content: [{ text: csv, type: 'text' }], role: 'user' }]
})
);
});
it('Restricts the routing to endpoints with zero data retention, disables the reasoning, sets the temperature to 0 and passes a PDF file to the model itself', async () => {
await aiService.getActivityRowsFromFile({
file: { buffer: Buffer.from('%PDF-1.7'), mediaType: 'application/pdf' },
locale: 'de-CH'
});
expect(chat).toHaveBeenCalledWith('vision-model', {
plugins: [{ id: 'file-parser', pdf: { engine: 'native' } }],
provider: { require_parameters: true, zdr: true },
reasoning: { effort: 'none' },
usage: { include: true }
});
expect(generateText).toHaveBeenCalledWith(
expect.objectContaining({ temperature: 0 })
);
});
it('Falls back to the general model if no vision model is set', async () => {
delete properties[PROPERTY_OPENROUTER_MODEL_VISION];
await aiService.getActivityRowsFromFile({
file: { buffer: Buffer.from('%PDF-1.7'), mediaType: 'application/pdf' },
locale: 'de-CH'
});
expect(chat).toHaveBeenCalledWith('general-model', expect.any(Object));
});
it('Gives the locale and the date of today in the instructions', async () => {
jest.useFakeTimers({ now: new Date('2026-10-11T12:00:00Z') });
try {
await aiService.getActivityRowsFromFile({
file: {
buffer: Buffer.from('%PDF-1.7'),
mediaType: 'application/pdf'
},
locale: 'de-CH'
});
} finally {
jest.useRealTimers();
}
const { instructions } = jest.mocked(generateText).mock.calls[0][0];
expect(instructions).toContain('the locale de-CH');
expect(instructions).toContain('Today is 2026-10-11');
});
it('Tells the vision model that a national number of a security is not a ticker symbol', async () => {
await aiService.getActivityRowsFromFile({
file: {
buffer: Buffer.from('%PDF-1.7'),
mediaType: 'application/pdf'
},
locale: 'de-CH'
});
const { instructions } = jest.mocked(generateText).mock.calls[0][0];
expect(instructions).toContain(
'A national number of a security, for example a valor (NKN), a WKN or a CUSIP, is not a ticker symbol.'
);
});
it('Tells the vision model to add the fees of a buy or a sell to its row', async () => {
await aiService.getActivityRowsFromFile({
file: {
buffer: Buffer.from('%PDF-1.7'),
mediaType: 'application/pdf'
},
locale: 'de-CH'
});
const { instructions } = jest.mocked(generateText).mock.calls[0][0];
expect(instructions).toContain(
'Add every fee, commission and tax of a buy or a sell, for example a commission, a stamp duty or an exchange fee, to the fee of its row.'
);
});
it('Gives an error for the caller if a cut output reaches the maximum number of output tokens', async () => {
jest.spyOn(Logger.prototype, 'warn').mockImplementation();
jest.mocked(generateText).mockRejectedValueOnce(
new NoObjectGeneratedError({
finishReason: 'length'
} as ConstructorParameters<typeof NoObjectGeneratedError>[0])
);
await expect(
aiService.getActivityRowsFromFile({
file: {
buffer: Buffer.from('%PDF-1.7'),
mediaType: 'application/pdf'
},
locale: 'de-CH'
})
).rejects.toThrow(CallerFacingError);
expect(generateText).toHaveBeenCalledTimes(1);
expect(Logger.prototype.warn).toHaveBeenCalled();
});
it('Gives an error for the caller if an output without any text reaches the maximum number of output tokens', async () => {
jest.spyOn(Logger.prototype, 'warn').mockImplementation();
jest.mocked(generateText).mockResolvedValueOnce({
finishReason: 'length',
get output() {
throw new Error('No output generated');
}
} as unknown as Awaited<ReturnType<typeof generateText>>);
await expect(
aiService.getActivityRowsFromFile({
file: {
buffer: Buffer.from('%PDF-1.7'),
mediaType: 'application/pdf'
},
locale: 'de-CH'
})
).rejects.toThrow(CallerFacingError);
expect(Logger.prototype.warn).toHaveBeenCalled();
});
it('Requests the rows one more time if the output does not agree with the schema', async () => {
jest.spyOn(Logger.prototype, 'warn').mockImplementation();
jest.mocked(generateText).mockRejectedValueOnce(
new NoObjectGeneratedError({
finishReason: 'stop',
response: { modelId: 'vision-model' },
usage: { totalTokens: 1000 }
} as ConstructorParameters<typeof NoObjectGeneratedError>[0])
);
await expect(
aiService.getActivityRowsFromFile({
abortSignal,
file: {
buffer: Buffer.from('%PDF-1.7'),
mediaType: 'application/pdf'
},
locale: 'de-CH'
})
).resolves.toEqual({ broker: 'Swissquote', rows });
expect(generateText).toHaveBeenCalledTimes(2);
const [[firstOptions], [secondOptions]] =
jest.mocked(generateText).mock.calls;
expect(secondOptions).toEqual(firstOptions);
expect(secondOptions.abortSignal).toBe(abortSignal);
expect(Logger.prototype.warn).toHaveBeenCalledWith(
expect.stringContaining(
'the model vision-model one more time after 1000 tokens'
)
);
});
it('Requests the rows one more time if the output is empty', async () => {
jest.spyOn(Logger.prototype, 'warn').mockImplementation();
jest.mocked(generateText).mockResolvedValueOnce({
finalStep: { response: { modelId: 'vision-model' } },
finishReason: 'other',
text: '',
usage: { totalTokens: 10 },
get output() {
throw new Error('No output generated');
}
} as unknown as Awaited<ReturnType<typeof generateText>>);
await expect(
aiService.getActivityRowsFromFile({
file: {
buffer: Buffer.from('%PDF-1.7'),
mediaType: 'application/pdf'
},
locale: 'de-CH'
})
).resolves.toEqual({ broker: 'Swissquote', rows });
expect(generateText).toHaveBeenCalledTimes(2);
expect(Logger.prototype.warn).toHaveBeenCalledWith(
expect.stringContaining(
'the model vision-model one more time after 10 tokens'
)
);
});
it('Passes on the error if the output does not agree with the schema a second time', async () => {
jest.spyOn(Logger.prototype, 'warn').mockImplementation();
const firstError = new NoObjectGeneratedError({
finishReason: 'stop'
} as ConstructorParameters<typeof NoObjectGeneratedError>[0]);
const secondError = new NoObjectGeneratedError({
finishReason: 'stop'
} as ConstructorParameters<typeof NoObjectGeneratedError>[0]);
jest
.mocked(generateText)
.mockRejectedValueOnce(firstError)
.mockRejectedValueOnce(secondError);
await expect(
aiService.getActivityRowsFromFile({
file: {
buffer: Buffer.from('%PDF-1.7'),
mediaType: 'application/pdf'
},
locale: 'de-CH'
})
).rejects.toBe(secondError);
expect(generateText).toHaveBeenCalledTimes(2);
});
it('Passes on the error if the content filter stops the output', async () => {
const error = new NoObjectGeneratedError({
finishReason: 'content-filter'
} as ConstructorParameters<typeof NoObjectGeneratedError>[0]);
jest.mocked(generateText).mockRejectedValueOnce(error);
await expect(
aiService.getActivityRowsFromFile({
file: {
buffer: Buffer.from('%PDF-1.7'),
mediaType: 'application/pdf'
},
locale: 'de-CH'
})
).rejects.toBe(error);
expect(generateText).toHaveBeenCalledTimes(1);
});
it('Passes on every other error of the vision model', async () => {
const error = new Error('Provider failed');
jest.mocked(generateText).mockRejectedValueOnce(error);
await expect(
aiService.getActivityRowsFromFile({
file: {
buffer: Buffer.from('%PDF-1.7'),
mediaType: 'application/pdf'
},
locale: 'de-CH'
})
).rejects.toBe(error);
expect(generateText).toHaveBeenCalledTimes(1);
});
});
describe('getActivitiesFromFile', () => {
const file = {
buffer: Buffer.from('%PDF-1.7'),
mediaType: 'application/pdf'
};
const user = {
accounts: [{ currency: 'CHF', id: 'account-id', name: 'Brokerage' }],
id: 'user-id',
settings: { settings: { baseCurrency: 'EUR', locale: 'de-CH' } }
} as unknown as UserWithSettings;
it('Reads the rows of the file and matches them with the accounts, the base currency and the id of the user', async () => {
const activities = [
{
currency: 'USD',
dataSource: 'YAHOO',
date: '2026-01-15',
fee: 1,
quantity: 10,
symbol: 'AAPL',
type: ActivityType.BUY,
unitPrice: 230
}
];
jest
.spyOn(aiService, 'getActivityRowsFromFile')
.mockResolvedValue({ broker: 'Swissquote', rows });
jest
.spyOn(aiService, 'getActivitiesFromRows')
.mockResolvedValue({ activities, rowsWithoutMatch: [] });
await expect(
aiService.getActivitiesFromFile({ abortSignal, file, user })
).resolves.toEqual({
activities,
assetProfiles: [],
rowsWithoutMatch: []
});
expect(aiService.getActivityRowsFromFile).toHaveBeenCalledWith({
abortSignal,
file,
locale: 'de-CH'
});
expect(aiService.getActivitiesFromRows).toHaveBeenCalledWith({
abortSignal,
rows,
accounts: user.accounts,
broker: 'Swissquote',
userCurrency: 'EUR',
userId: 'user-id'
});
});
it('Gives a fee, an interest or a liability a custom asset profile with its description as name', async () => {
const fee = {
currency: 'CHF',
date: '2026-01-15',
fee: 5,
quantity: 0,
symbol: 'Custody fee',
type: ActivityType.FEE,
unitPrice: 0
};
jest
.spyOn(aiService, 'getActivityRowsFromFile')
.mockResolvedValue({ broker: 'Swissquote', rows });
jest.spyOn(aiService, 'getActivitiesFromRows').mockResolvedValue({
activities: [fee, { ...fee, date: '2026-02-15' }],
rowsWithoutMatch: []
});
const { activities, assetProfiles } =
await aiService.getActivitiesFromFile({ file, user });
const [{ symbol }] = assetProfiles;
expect(isValidCustomAssetProfileSymbol(symbol)).toBe(true);
expect(assetProfiles).toEqual([
{
symbol,
currency: 'CHF',
dataSource: DataSource.MANUAL,
name: 'Custody fee'
}
]);
expect(activities).toEqual([
{ ...fee, symbol, dataSource: DataSource.MANUAL },
{ ...fee, symbol, dataSource: DataSource.MANUAL, date: '2026-02-15' }
]);
});
it('Reads the file in the default locale if the user has no locale', async () => {
jest
.spyOn(aiService, 'getActivityRowsFromFile')
.mockResolvedValue({ broker: null, rows: [] });
jest
.spyOn(aiService, 'getActivitiesFromRows')
.mockResolvedValue({ activities: [], rowsWithoutMatch: [] });
await aiService.getActivitiesFromFile({
file,
user: {
...user,
settings: { settings: { baseCurrency: 'EUR' } }
} as unknown as UserWithSettings
});
expect(aiService.getActivityRowsFromFile).toHaveBeenCalledWith(
expect.objectContaining({ locale: DEFAULT_LOCALE })
);
});
});
describe('getActivitiesFromRows', () => {
const accounts: AccountToMatch[] = [
{ currency: 'CHF', id: 'account-id', name: 'Brokerage' }
];
const rowOfMicrosoft = createActivityRow({
accountName: null,
isin: 'US5949181045',
name: 'Microsoft Corporation',
symbol: 'MSFT'
});
const userCurrency = 'EUR';
const userId = 'user-id';
function mockRowMatches({
accounts: accountMatches = [],
assetProfilesOfSearch,
assets: assetMatches = []
}: Partial<z.infer<typeof ROW_MATCHES_OUTPUT>> & {
assetProfilesOfSearch?: { dataSource: string; symbol: string }[];
}) {
jest.mocked(mcpService.searchAssetProfiles).mockResolvedValue({
content: [
{
text: JSON.stringify({
assetProfiles: assetProfilesOfSearch ?? assetMatches
}),
type: 'text'
}
]
});
jest.mocked(generateText).mockResolvedValueOnce({
output: { accounts: accountMatches, assets: assetMatches },
steps: [{}],
totalUsage: { totalTokens: 2000 }
} as unknown as Awaited<ReturnType<typeof generateText>>);
}
function mockSearches(
searchResultByQuery: Record<
string,
{ dataSource: string; symbol: string }[] | Error
>
) {
jest
.mocked(mcpService.searchAssetProfiles)
.mockImplementation(({ query }) => {
const searchResult = searchResultByQuery[query] ?? [];
if (searchResult instanceof Error) {
return Promise.reject(searchResult);
}
return Promise.resolve({
content: [
{
text: JSON.stringify({ assetProfiles: searchResult }),
type: 'text' as const
}
]
});
});
}
function mockHoldings({
dataSource = 'YAHOO'
}: { dataSource?: string } = {}) {
jest.mocked(mcpService.getAssetProfilesOfUser).mockResolvedValue([
{
dataSource,
currency: 'USD',
isin: 'IE00BK5BQT80',
name: 'Vanguard FTSE All-World UCITS ETF',
symbol: 'VWRA.SW'
},
{
dataSource,
currency: 'USD',
isin: null,
name: 'Apple Inc.',
symbol: 'AAPL'
}
]);
}
it('Gives an activity for each row whose asset matches an asset profile', async () => {
const row = createActivityRow({ currency: null });
mockRowMatches({
accounts: [{ accountId: 'account-id', id: 0 }],
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'AAPL' }
]
});
await expect(
aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [row]
})
).resolves.toEqual({
activities: [
{
accountId: 'account-id',
currency: 'USD',
dataSource: 'YAHOO',
date: row.date,
fee: row.fee,
quantity: row.quantity,
symbol: 'AAPL',
type: ActivityType.BUY,
unitPrice: row.unitPrice
}
],
rowsWithoutMatch: []
});
expect(Logger.prototype.log).toHaveBeenCalledWith(
expect.stringContaining(
'Matched 1 of 1 assets and 1 of 1 account hints with 1 results of 1 searches'
)
);
});
it('Gives the currency of the row before the currency of the asset profile', async () => {
mockRowMatches({
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'AAPL' }
]
});
const { activities } = await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [createActivityRow({ accountName: null, currency: 'CHF' })]
});
expect(activities[0].currency).toBe('CHF');
});
it('Gives the absolute values of a negative fee, quantity and unit price', async () => {
mockRowMatches({
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'AAPL' }
]
});
const { activities } = await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [
createActivityRow({
accountName: null,
fee: -1,
quantity: -10,
type: ActivityType.SELL,
unitPrice: -230
})
]
});
expect(activities[0]).toMatchObject({
fee: 1,
quantity: 10,
unitPrice: 230
});
});
it('Gives a row whose asset has no match as a row without a match', async () => {
const row = createActivityRow({ accountName: null });
mockRowMatches({
assets: [{ currency: null, dataSource: null, id: 0, symbol: null }]
});
await expect(
aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [row]
})
).resolves.toEqual({ activities: [], rowsWithoutMatch: [row] });
});
it('Gives a row with a data source which is not valid as a row without a match', async () => {
const row = createActivityRow({ accountName: null });
mockRowMatches({
assets: [
{ currency: 'USD', dataSource: 'yahoo', id: 0, symbol: 'AAPL' }
]
});
await expect(
aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [row]
})
).resolves.toEqual({ activities: [], rowsWithoutMatch: [row] });
});
it('Gives a row whose asset profile no search gave as a row without a match and logs the left out match', async () => {
jest.spyOn(Logger.prototype, 'warn').mockImplementation();
const row = createActivityRow({ accountName: null });
mockRowMatches({
assetProfilesOfSearch: [{ dataSource: 'YAHOO', symbol: 'AAPL' }],
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'AAPL.XX' }
]
});
await expect(
aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [row]
})
).resolves.toEqual({ activities: [], rowsWithoutMatch: [row] });
expect(Logger.prototype.log).toHaveBeenCalledWith(
expect.stringContaining(
'Matched 0 of 1 assets and 0 of 0 account hints with 1 results of 1 searches'
)
);
expect(Logger.prototype.warn).toHaveBeenCalledWith(
'Left out 1 asset matches which neither the search of their asset nor the holdings gave'
);
});
it('Gives a row whose asset match only the search of another asset gave as a row without a match', async () => {
jest.spyOn(Logger.prototype, 'warn').mockImplementation();
const rowOfApple = createActivityRow({ accountName: null });
mockRowMatches({
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'MSFT' },
{ currency: 'USD', dataSource: 'YAHOO', id: 1, symbol: 'MSFT' }
]
});
mockSearches({
US0378331005: [{ dataSource: 'YAHOO', symbol: 'AAPL' }],
US5949181045: [{ dataSource: 'YAHOO', symbol: 'MSFT' }]
});
await expect(
aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [rowOfApple, rowOfMicrosoft]
})
).resolves.toEqual({
activities: [expect.objectContaining({ symbol: 'MSFT' })],
rowsWithoutMatch: [rowOfApple]
});
expect(Logger.prototype.warn).toHaveBeenCalledWith(
'Left out 1 asset matches which neither the search of their asset nor the holdings gave'
);
});
it('Gives an activity for a row whose asset matches a holding which no search gave', async () => {
const row = createActivityRow({
accountName: null,
currency: 'CHF',
isin: 'IE00BK5BQT80',
name: 'Vanguard FTSE All-World UCITS ETF USD Accumulating',
symbol: null
});
mockRowMatches({
assetProfilesOfSearch: [],
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'VWRA.SW' }
]
});
mockHoldings();
await expect(
aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [row]
})
).resolves.toEqual({
activities: [
expect.objectContaining({
currency: 'CHF',
dataSource: 'YAHOO',
symbol: 'VWRA.SW'
})
],
rowsWithoutMatch: []
});
});
it('Gives an activity for a row whose asset matches a holding with the same ISIN with spaces and in lower case', async () => {
const row = createActivityRow({
accountName: null,
isin: 'ie00 bk5b qt80',
name: 'Vanguard FTSE All-World UCITS ETF USD Accumulating',
symbol: null
});
mockRowMatches({
assetProfilesOfSearch: [],
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'VWRA.SW' }
]
});
mockHoldings();
await expect(
aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [row]
})
).resolves.toEqual({
activities: [
expect.objectContaining({ dataSource: 'YAHOO', symbol: 'VWRA.SW' })
],
rowsWithoutMatch: []
});
});
it('Gives an activity for a row whose asset matches a holding without an ISIN which no search gave', async () => {
const row = createActivityRow({
accountName: null,
name: 'APPLE INC',
symbol: null
});
mockRowMatches({
assetProfilesOfSearch: [],
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'AAPL' }
]
});
mockHoldings();
await expect(
aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [row]
})
).resolves.toEqual({
activities: [
expect.objectContaining({ dataSource: 'YAHOO', symbol: 'AAPL' })
],
rowsWithoutMatch: []
});
});
it('Gives a row whose asset match has the symbol of a holding but another data source as a row without a match', async () => {
jest.spyOn(Logger.prototype, 'warn').mockImplementation();
const row = createActivityRow({
accountName: null,
isin: 'IE00BK5BQT80'
});
mockRowMatches({
assetProfilesOfSearch: [],
assets: [
{ currency: 'USD', dataSource: 'MANUAL', id: 0, symbol: 'VWRA.SW' }
]
});
mockHoldings();
await expect(
aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [row]
})
).resolves.toEqual({ activities: [], rowsWithoutMatch: [row] });
});
it('Gives a row whose asset match is a holding with another ISIN as a row without a match and logs the left out match', async () => {
jest.spyOn(Logger.prototype, 'warn').mockImplementation();
const row = createActivityRow({
accountName: null,
isin: 'IE00B3RBWM25',
name: 'Vanguard FTSE All-World UCITS ETF USD Distributing',
symbol: null
});
mockRowMatches({
assetProfilesOfSearch: [],
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'VWRA.SW' }
]
});
mockHoldings();
await expect(
aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [row]
})
).resolves.toEqual({ activities: [], rowsWithoutMatch: [row] });
expect(Logger.prototype.warn).toHaveBeenCalledWith(
'Left out 1 asset matches which neither the search of their asset nor the holdings gave'
);
});
it('Gives an activity for a row whose asset matches a holding with an encoded data source and checks the decoded data source', async () => {
const encodedDataSource = encodeDataSource(DataSource.YAHOO);
const row = createActivityRow({
accountName: null,
isin: 'IE00BK5BQT80',
symbol: null
});
mockRowMatches({
assetProfilesOfSearch: [],
assets: [
{
currency: 'USD',
dataSource: encodedDataSource,
id: 0,
symbol: 'VWRA.SW'
}
]
});
mockHoldings({ dataSource: encodedDataSource });
await expect(
aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [row]
})
).resolves.toEqual({
activities: [
expect.objectContaining({
dataSource: encodedDataSource,
symbol: 'VWRA.SW'
})
],
rowsWithoutMatch: []
});
});
it('Passes no holding with a data source which is not configured to the model and gives a row whose asset match is such a holding as a row without a match', async () => {
jest.spyOn(Logger.prototype, 'warn').mockImplementation();
jest
.mocked(dataProviderService.getDataSources)
.mockResolvedValue([DataSource.MANUAL]);
const row = createActivityRow({
accountName: null,
isin: 'IE00BK5BQT80',
symbol: null
});
mockRowMatches({
assetProfilesOfSearch: [],
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'VWRA.SW' }
]
});
mockHoldings();
await expect(
aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [row]
})
).resolves.toEqual({ activities: [], rowsWithoutMatch: [row] });
const { prompt } = jest.mocked(generateText).mock.calls[0][0];
expect(JSON.parse(prompt as string)).toHaveProperty('holdings', []);
});
it('Matches a row without an account name by the broker of the file', async () => {
mockRowMatches({
accounts: [{ accountId: 'account-id', id: 0 }],
assets: [
{ currency: 'CHF', dataSource: 'YAHOO', id: 0, symbol: 'ROG.SW' }
]
});
const { activities } = await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
broker: 'Swissquote',
rows: [
createActivityRow({ accountName: null }),
createActivityRow({ accountName: null, type: ActivityType.SELL })
]
});
expect(activities.map(({ accountId }) => accountId)).toEqual([
'account-id',
'account-id'
]);
const { prompt } = jest.mocked(generateText).mock.calls[0][0];
const { accountHints } = JSON.parse(prompt as string) as {
accountHints: AccountHint[];
};
expect(accountHints).toEqual([
{ accountName: null, broker: 'Swissquote', id: 0 }
]);
});
it('Ignores an account id which is not the id of an account of the user', async () => {
mockRowMatches({
accounts: [{ accountId: 'unknown-account-id', id: 0 }],
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'AAPL' }
]
});
const { activities } = await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [createActivityRow()]
});
expect(activities[0].accountId).toBeUndefined();
});
it('Gives a fee, an interest or a liability its description as symbol without a model call', async () => {
const rowsOfNonInvestments = [
ActivityType.FEE,
ActivityType.INTEREST,
ActivityType.LIABILITY
].map((type) => {
return createActivityRow({
type,
accountName: null,
currency: null,
isin: null,
name: `Description of ${type}`,
symbol: null
});
});
const { activities, rowsWithoutMatch } =
await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: rowsOfNonInvestments
});
expect(generateText).not.toHaveBeenCalled();
expect(
activities.map(({ currency, dataSource, symbol, type }) => {
return { currency, dataSource, symbol, type };
})
).toEqual(
rowsOfNonInvestments.map(({ name, type }) => {
return {
type,
currency: userCurrency,
dataSource: undefined,
symbol: name
};
})
);
expect(rowsWithoutMatch).toEqual([]);
});
it('Gives a fee without a currency the currency of its account', async () => {
mockRowMatches({
accounts: [{ accountId: 'account-id', id: 0 }]
});
const { activities } = await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [
createActivityRow({
currency: null,
isin: null,
name: 'Custody fee',
symbol: null,
type: ActivityType.FEE
})
]
});
expect(activities[0]).toMatchObject({
accountId: 'account-id',
currency: 'CHF'
});
});
it('Gives a fee without a description as a row without a match', async () => {
const row = createActivityRow({
accountName: null,
isin: null,
name: null,
symbol: null,
type: ActivityType.FEE
});
await expect(
aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [row]
})
).resolves.toEqual({ activities: [], rowsWithoutMatch: [row] });
});
it('Passes each asset with the asset profiles of its search, each account hint one time and the accounts to the model', async () => {
mockRowMatches({
assetProfilesOfSearch: [{ dataSource: 'YAHOO', symbol: 'AAPL' }],
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'AAPL' }
]
});
const { activities } = await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
broker: 'Swissquote',
rows: [
createActivityRow(),
createActivityRow({ type: ActivityType.SELL }),
createActivityRow({
accountName: 'Depot 1',
type: ActivityType.DIVIDEND
})
]
});
expect(activities).toHaveLength(3);
const { prompt } = jest.mocked(generateText).mock.calls[0][0];
expect(JSON.parse(prompt as string)).toEqual({
accountHints: [
{ accountName: 'Brokerage', broker: 'Swissquote', id: 0 },
{ accountName: 'Depot 1', broker: 'Swissquote', id: 1 }
],
accounts: '## Accounts',
assets: [
{
assetProfiles: [{ dataSource: 'YAHOO', symbol: 'AAPL' }],
currency: 'USD',
id: 0,
isin: 'US0378331005',
name: 'Apple Inc.',
symbol: 'AAPL'
}
],
holdings: []
});
});
it('Passes each asset with the asset profiles of its own search to the model', async () => {
mockRowMatches({});
mockSearches({
US0378331005: [{ dataSource: 'YAHOO', symbol: 'AAPL' }],
US5949181045: [{ dataSource: 'YAHOO', symbol: 'MSFT' }]
});
await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [createActivityRow({ accountName: null }), rowOfMicrosoft]
});
const { prompt } = jest.mocked(generateText).mock.calls[0][0];
const { assets } = JSON.parse(prompt as string) as {
assets: { assetProfiles: unknown[]; id: number }[];
};
expect(
assets.map(({ assetProfiles, id }) => {
return { assetProfiles, id };
})
).toEqual([
{ assetProfiles: [{ dataSource: 'YAHOO', symbol: 'AAPL' }], id: 0 },
{ assetProfiles: [{ dataSource: 'YAHOO', symbol: 'MSFT' }], id: 1 }
]);
});
it('Searches each asset with the tool of the server of the Model Context Protocol by the ISIN, then by the ticker symbol, then by the name, until a search gives asset profiles', async () => {
mockRowMatches({});
jest
.mocked(mcpService.searchAssetProfiles)
.mockResolvedValueOnce({
content: [{ text: '{ "assetProfiles": [] }', type: 'text' }]
})
.mockResolvedValueOnce({
content: [
{
text: JSON.stringify({
assetProfiles: [{ dataSource: 'YAHOO', symbol: 'AAPL' }]
}),
type: 'text'
}
]
});
await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [createActivityRow({ accountName: null })]
});
expect(jest.mocked(mcpService.searchAssetProfiles).mock.calls).toEqual([
[{ userId, query: 'US0378331005' }],
[{ userId, query: 'AAPL' }]
]);
});
it('Does not search a missing or too short value of an asset', async () => {
mockRowMatches({});
await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [
createActivityRow({
accountName: null,
isin: null,
name: 'Visa Inc.',
symbol: 'V'
})
]
});
expect(jest.mocked(mcpService.searchAssetProfiles).mock.calls).toEqual([
[{ userId, query: 'Visa Inc.' }]
]);
});
it('Searches the next value of an asset if a search fails and logs the failure', async () => {
jest.spyOn(Logger.prototype, 'warn').mockImplementation();
mockRowMatches({
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'AAPL' }
]
});
jest
.mocked(mcpService.searchAssetProfiles)
.mockRejectedValueOnce(new Error('Search failed'));
const { activities } = await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [createActivityRow({ accountName: null })]
});
expect(activities).toEqual([expect.objectContaining({ symbol: 'AAPL' })]);
expect(jest.mocked(mcpService.searchAssetProfiles).mock.calls).toEqual([
[{ userId, query: 'US0378331005' }],
[{ userId, query: 'AAPL' }]
]);
expect(Logger.prototype.warn).toHaveBeenCalledWith(
'Could not search the asset profiles: Search failed'
);
});
it('Gives the rows of an asset whose searches all fail as rows without a match and matches the other assets', async () => {
jest.spyOn(Logger.prototype, 'warn').mockImplementation();
const rowOfApple = createActivityRow({ accountName: null });
const searchError = new Error('Search failed');
mockRowMatches({
assets: [
{ currency: null, dataSource: null, id: 0, symbol: null },
{ currency: 'USD', dataSource: 'YAHOO', id: 1, symbol: 'MSFT' }
]
});
mockSearches({
AAPL: searchError,
'Apple Inc.': searchError,
US0378331005: searchError,
US5949181045: [{ dataSource: 'YAHOO', symbol: 'MSFT' }]
});
await expect(
aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [rowOfApple, rowOfMicrosoft]
})
).resolves.toEqual({
activities: [expect.objectContaining({ symbol: 'MSFT' })],
rowsWithoutMatch: [rowOfApple]
});
expect(Logger.prototype.warn).toHaveBeenCalledTimes(3);
});
it('Gets the accounts with the tool of the server of the Model Context Protocol without values', async () => {
mockRowMatches({});
await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [createActivityRow()]
});
expect(mcpService.getAccounts).toHaveBeenCalledWith({
userId,
withValues: false
});
});
it('Does not get the accounts without an account hint', async () => {
mockRowMatches({});
await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [createActivityRow({ accountName: null })]
});
expect(mcpService.getAccounts).not.toHaveBeenCalled();
const { prompt } = jest.mocked(generateText).mock.calls[0][0];
expect(JSON.parse(prompt as string)).not.toHaveProperty('accounts');
});
it('Passes no accounts to the model and continues if the accounts cannot be got', async () => {
jest.spyOn(Logger.prototype, 'warn').mockImplementation();
mockRowMatches({
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'AAPL' }
]
});
jest
.mocked(mcpService.getAccounts)
.mockRejectedValueOnce(new Error('Database failed'));
const { activities } = await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [createActivityRow()]
});
expect(activities).toEqual([
expect.objectContaining({ accountId: undefined, symbol: 'AAPL' })
]);
const { prompt } = jest.mocked(generateText).mock.calls[0][0];
expect(JSON.parse(prompt as string)).not.toHaveProperty('accounts');
expect(Logger.prototype.warn).toHaveBeenCalledWith(
'Could not get the accounts: Database failed'
);
});
it('Gets the holdings of the user from the server of the Model Context Protocol', async () => {
mockRowMatches({});
await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [createActivityRow()]
});
expect(mcpService.getAssetProfilesOfUser).toHaveBeenCalledWith({
userId
});
});
it('Passes the currency, the data source, the ISIN, the name and the symbol of each holding to the model', async () => {
mockRowMatches({});
mockHoldings();
await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [createActivityRow()]
});
const { prompt } = jest.mocked(generateText).mock.calls[0][0];
expect(JSON.parse(prompt as string)).toHaveProperty('holdings', [
{
currency: 'USD',
dataSource: 'YAHOO',
isin: 'IE00BK5BQT80',
name: 'Vanguard FTSE All-World UCITS ETF',
symbol: 'VWRA.SW'
},
{
currency: 'USD',
dataSource: 'YAHOO',
isin: null,
name: 'Apple Inc.',
symbol: 'AAPL'
}
]);
});
it('Does not get the holdings without an asset', async () => {
mockRowMatches({});
await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [
createActivityRow({
fee: 5,
name: 'Custody fee',
quantity: 0,
type: ActivityType.FEE,
unitPrice: 0
})
]
});
expect(mcpService.getAssetProfilesOfUser).not.toHaveBeenCalled();
expect(dataProviderService.getDataSources).not.toHaveBeenCalled();
const { prompt } = jest.mocked(generateText).mock.calls[0][0];
expect(JSON.parse(prompt as string)).not.toHaveProperty('holdings');
});
it('Passes no holdings to the model and continues if the holdings cannot be got', async () => {
jest.spyOn(Logger.prototype, 'warn').mockImplementation();
mockRowMatches({
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'AAPL' }
]
});
jest
.mocked(mcpService.getAssetProfilesOfUser)
.mockRejectedValueOnce(new Error('Query failed'));
const { activities } = await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [createActivityRow()]
});
expect(activities).toEqual([expect.objectContaining({ symbol: 'AAPL' })]);
const { prompt } = jest.mocked(generateText).mock.calls[0][0];
expect(JSON.parse(prompt as string)).not.toHaveProperty('holdings');
expect(Logger.prototype.warn).toHaveBeenCalledWith(
'Could not get the holdings: Query failed'
);
});
it('Passes no holdings to the model and continues if the data sources cannot be got', async () => {
jest.spyOn(Logger.prototype, 'warn').mockImplementation();
mockRowMatches({
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'AAPL' }
]
});
mockHoldings();
jest
.mocked(dataProviderService.getDataSources)
.mockRejectedValueOnce(new Error('Database failed'));
const { activities } = await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [createActivityRow()]
});
expect(activities).toEqual([expect.objectContaining({ symbol: 'AAPL' })]);
const { prompt } = jest.mocked(generateText).mock.calls[0][0];
expect(JSON.parse(prompt as string)).not.toHaveProperty('holdings');
expect(Logger.prototype.warn).toHaveBeenCalledWith(
'Could not get the holdings: Database failed'
);
});
it('Restricts the routing to endpoints with zero data retention, disables the reasoning, sets the temperature to 0 and gives the model no tools', async () => {
mockRowMatches({});
await aiService.getActivitiesFromRows({
abortSignal,
accounts,
userCurrency,
userId,
rows: [createActivityRow()]
});
expect(chat).toHaveBeenCalledWith('agent-model', {
provider: { require_parameters: true, zdr: true },
reasoning: { effort: 'none' },
usage: { include: true }
});
expect(generateText).toHaveBeenCalledWith(
expect.objectContaining({
abortSignal,
model,
output: { schema: ROW_MATCHES_OUTPUT },
temperature: 0
})
);
expect(jest.mocked(generateText).mock.calls[0][0]).not.toHaveProperty(
'tools'
);
});
it('Requests the matches one more time if the output does not agree with the schema', async () => {
jest.spyOn(Logger.prototype, 'warn').mockImplementation();
jest.mocked(generateText).mockRejectedValueOnce(
new NoObjectGeneratedError({
finishReason: 'stop',
response: { modelId: 'agent-model' },
usage: { totalTokens: 1000 }
} as ConstructorParameters<typeof NoObjectGeneratedError>[0])
);
mockRowMatches({
assets: [
{ currency: 'USD', dataSource: 'YAHOO', id: 0, symbol: 'AAPL' }
]
});
const { activities } = await aiService.getActivitiesFromRows({
abortSignal,
accounts,
userCurrency,
userId,
rows: [createActivityRow({ accountName: null })]
});
expect(activities).toEqual([expect.objectContaining({ symbol: 'AAPL' })]);
expect(generateText).toHaveBeenCalledTimes(2);
const [[firstOptions], [secondOptions]] =
jest.mocked(generateText).mock.calls;
expect(secondOptions).toEqual(firstOptions);
expect(secondOptions.abortSignal).toBe(abortSignal);
expect(Logger.prototype.warn).toHaveBeenCalledWith(
expect.stringContaining(
'the model agent-model one more time after 1000 tokens'
)
);
});
it('Falls back to the general model if no agent model is set', async () => {
delete properties[PROPERTY_OPENROUTER_MODEL_AGENT];
mockRowMatches({});
await aiService.getActivitiesFromRows({
accounts,
userCurrency,
userId,
rows: [createActivityRow()]
});
expect(chat).toHaveBeenCalledWith('general-model', expect.any(Object));
});
});
});