| |
| |
| |
| |
| |
|
|
| import { describe, it, expect } from 'vitest'; |
| import { |
| getResponseText, |
| getResponseTextFromParts, |
| getFunctionCalls, |
| getFunctionCallsFromParts, |
| getFunctionCallsAsJson, |
| getFunctionCallsFromPartsAsJson, |
| getStructuredResponse, |
| getStructuredResponseFromParts, |
| } from './generateContentResponseUtilities.js'; |
| import { |
| GenerateContentResponse, |
| Part, |
| FinishReason, |
| SafetyRating, |
| } from '@google/genai'; |
|
|
| const mockTextPart = (text: string): Part => ({ text }); |
| const mockFunctionCallPart = ( |
| name: string, |
| args?: Record<string, unknown>, |
| ): Part => ({ |
| functionCall: { name, args: args ?? {} }, |
| }); |
|
|
| const mockResponse = ( |
| parts: Part[], |
| finishReason: FinishReason = FinishReason.STOP, |
| safetyRatings: SafetyRating[] = [], |
| ): GenerateContentResponse => ({ |
| candidates: [ |
| { |
| content: { |
| parts, |
| role: 'model', |
| }, |
| index: 0, |
| finishReason, |
| safetyRatings, |
| }, |
| ], |
| promptFeedback: { |
| safetyRatings: [], |
| }, |
| text: undefined, |
| data: undefined, |
| functionCalls: undefined, |
| executableCode: undefined, |
| codeExecutionResult: undefined, |
| }); |
|
|
| const minimalMockResponse = ( |
| candidates: GenerateContentResponse['candidates'], |
| ): GenerateContentResponse => ({ |
| candidates, |
| promptFeedback: { safetyRatings: [] }, |
| text: undefined, |
| data: undefined, |
| functionCalls: undefined, |
| executableCode: undefined, |
| codeExecutionResult: undefined, |
| }); |
|
|
| describe('generateContentResponseUtilities', () => { |
| describe('getResponseText', () => { |
| it('should return undefined for no candidates', () => { |
| expect(getResponseText(minimalMockResponse(undefined))).toBeUndefined(); |
| }); |
| it('should return undefined for empty candidates array', () => { |
| expect(getResponseText(minimalMockResponse([]))).toBeUndefined(); |
| }); |
| it('should return undefined for no parts', () => { |
| const response = mockResponse([]); |
| expect(getResponseText(response)).toBeUndefined(); |
| }); |
| it('should extract text from a single text part', () => { |
| const response = mockResponse([mockTextPart('Hello')]); |
| expect(getResponseText(response)).toBe('Hello'); |
| }); |
| it('should concatenate text from multiple text parts', () => { |
| const response = mockResponse([ |
| mockTextPart('Hello '), |
| mockTextPart('World'), |
| ]); |
| expect(getResponseText(response)).toBe('Hello World'); |
| }); |
| it('should ignore function call parts', () => { |
| const response = mockResponse([ |
| mockTextPart('Hello '), |
| mockFunctionCallPart('testFunc'), |
| mockTextPart('World'), |
| ]); |
| expect(getResponseText(response)).toBe('Hello World'); |
| }); |
| it('should return undefined if only function call parts exist', () => { |
| const response = mockResponse([ |
| mockFunctionCallPart('testFunc'), |
| mockFunctionCallPart('anotherFunc'), |
| ]); |
| expect(getResponseText(response)).toBeUndefined(); |
| }); |
| }); |
|
|
| describe('getResponseTextFromParts', () => { |
| it('should return undefined for no parts', () => { |
| expect(getResponseTextFromParts([])).toBeUndefined(); |
| }); |
| it('should extract text from a single text part', () => { |
| expect(getResponseTextFromParts([mockTextPart('Hello')])).toBe('Hello'); |
| }); |
| it('should concatenate text from multiple text parts', () => { |
| expect( |
| getResponseTextFromParts([ |
| mockTextPart('Hello '), |
| mockTextPart('World'), |
| ]), |
| ).toBe('Hello World'); |
| }); |
| it('should ignore function call parts', () => { |
| expect( |
| getResponseTextFromParts([ |
| mockTextPart('Hello '), |
| mockFunctionCallPart('testFunc'), |
| mockTextPart('World'), |
| ]), |
| ).toBe('Hello World'); |
| }); |
| it('should return undefined if only function call parts exist', () => { |
| expect( |
| getResponseTextFromParts([ |
| mockFunctionCallPart('testFunc'), |
| mockFunctionCallPart('anotherFunc'), |
| ]), |
| ).toBeUndefined(); |
| }); |
| }); |
|
|
| describe('getFunctionCalls', () => { |
| it('should return undefined for no candidates', () => { |
| expect(getFunctionCalls(minimalMockResponse(undefined))).toBeUndefined(); |
| }); |
| it('should return undefined for empty candidates array', () => { |
| expect(getFunctionCalls(minimalMockResponse([]))).toBeUndefined(); |
| }); |
| it('should return undefined for no parts', () => { |
| const response = mockResponse([]); |
| expect(getFunctionCalls(response)).toBeUndefined(); |
| }); |
| it('should extract a single function call', () => { |
| const func = { name: 'testFunc', args: { a: 1 } }; |
| const response = mockResponse([ |
| mockFunctionCallPart(func.name, func.args), |
| ]); |
| expect(getFunctionCalls(response)).toEqual([func]); |
| }); |
| it('should extract multiple function calls', () => { |
| const func1 = { name: 'testFunc1', args: { a: 1 } }; |
| const func2 = { name: 'testFunc2', args: { b: 2 } }; |
| const response = mockResponse([ |
| mockFunctionCallPart(func1.name, func1.args), |
| mockFunctionCallPart(func2.name, func2.args), |
| ]); |
| expect(getFunctionCalls(response)).toEqual([func1, func2]); |
| }); |
| it('should ignore text parts', () => { |
| const func = { name: 'testFunc', args: { a: 1 } }; |
| const response = mockResponse([ |
| mockTextPart('Some text'), |
| mockFunctionCallPart(func.name, func.args), |
| mockTextPart('More text'), |
| ]); |
| expect(getFunctionCalls(response)).toEqual([func]); |
| }); |
| it('should return undefined if only text parts exist', () => { |
| const response = mockResponse([ |
| mockTextPart('Some text'), |
| mockTextPart('More text'), |
| ]); |
| expect(getFunctionCalls(response)).toBeUndefined(); |
| }); |
| }); |
|
|
| describe('getFunctionCallsFromParts', () => { |
| it('should return undefined for no parts', () => { |
| expect(getFunctionCallsFromParts([])).toBeUndefined(); |
| }); |
| it('should extract a single function call', () => { |
| const func = { name: 'testFunc', args: { a: 1 } }; |
| expect( |
| getFunctionCallsFromParts([mockFunctionCallPart(func.name, func.args)]), |
| ).toEqual([func]); |
| }); |
| it('should extract multiple function calls', () => { |
| const func1 = { name: 'testFunc1', args: { a: 1 } }; |
| const func2 = { name: 'testFunc2', args: { b: 2 } }; |
| expect( |
| getFunctionCallsFromParts([ |
| mockFunctionCallPart(func1.name, func1.args), |
| mockFunctionCallPart(func2.name, func2.args), |
| ]), |
| ).toEqual([func1, func2]); |
| }); |
| it('should ignore text parts', () => { |
| const func = { name: 'testFunc', args: { a: 1 } }; |
| expect( |
| getFunctionCallsFromParts([ |
| mockTextPart('Some text'), |
| mockFunctionCallPart(func.name, func.args), |
| mockTextPart('More text'), |
| ]), |
| ).toEqual([func]); |
| }); |
| it('should return undefined if only text parts exist', () => { |
| expect( |
| getFunctionCallsFromParts([ |
| mockTextPart('Some text'), |
| mockTextPart('More text'), |
| ]), |
| ).toBeUndefined(); |
| }); |
| }); |
|
|
| describe('getFunctionCallsAsJson', () => { |
| it('should return JSON string of function calls', () => { |
| const func1 = { name: 'testFunc1', args: { a: 1 } }; |
| const func2 = { name: 'testFunc2', args: { b: 2 } }; |
| const response = mockResponse([ |
| mockFunctionCallPart(func1.name, func1.args), |
| mockTextPart('text in between'), |
| mockFunctionCallPart(func2.name, func2.args), |
| ]); |
| const expectedJson = JSON.stringify([func1, func2], null, 2); |
| expect(getFunctionCallsAsJson(response)).toBe(expectedJson); |
| }); |
| it('should return undefined if no function calls', () => { |
| const response = mockResponse([mockTextPart('Hello')]); |
| expect(getFunctionCallsAsJson(response)).toBeUndefined(); |
| }); |
| }); |
|
|
| describe('getFunctionCallsFromPartsAsJson', () => { |
| it('should return JSON string of function calls from parts', () => { |
| const func1 = { name: 'testFunc1', args: { a: 1 } }; |
| const func2 = { name: 'testFunc2', args: { b: 2 } }; |
| const parts = [ |
| mockFunctionCallPart(func1.name, func1.args), |
| mockTextPart('text in between'), |
| mockFunctionCallPart(func2.name, func2.args), |
| ]; |
| const expectedJson = JSON.stringify([func1, func2], null, 2); |
| expect(getFunctionCallsFromPartsAsJson(parts)).toBe(expectedJson); |
| }); |
| it('should return undefined if no function calls in parts', () => { |
| const parts = [mockTextPart('Hello')]; |
| expect(getFunctionCallsFromPartsAsJson(parts)).toBeUndefined(); |
| }); |
| }); |
|
|
| describe('getStructuredResponse', () => { |
| it('should return only text if only text exists', () => { |
| const response = mockResponse([mockTextPart('Hello World')]); |
| expect(getStructuredResponse(response)).toBe('Hello World'); |
| }); |
| it('should return only function call JSON if only function calls exist', () => { |
| const func = { name: 'testFunc', args: { data: 'payload' } }; |
| const response = mockResponse([ |
| mockFunctionCallPart(func.name, func.args), |
| ]); |
| const expectedJson = JSON.stringify([func], null, 2); |
| expect(getStructuredResponse(response)).toBe(expectedJson); |
| }); |
| it('should return text and function call JSON if both exist', () => { |
| const text = 'Consider this data:'; |
| const func = { name: 'processData', args: { item: 42 } }; |
| const response = mockResponse([ |
| mockTextPart(text), |
| mockFunctionCallPart(func.name, func.args), |
| ]); |
| const expectedJson = JSON.stringify([func], null, 2); |
| expect(getStructuredResponse(response)).toBe(`${text}\n${expectedJson}`); |
| }); |
| it('should return undefined if neither text nor function calls exist', () => { |
| const response = mockResponse([]); |
| expect(getStructuredResponse(response)).toBeUndefined(); |
| }); |
| }); |
|
|
| describe('getStructuredResponseFromParts', () => { |
| it('should return only text if only text exists in parts', () => { |
| const parts = [mockTextPart('Hello World')]; |
| expect(getStructuredResponseFromParts(parts)).toBe('Hello World'); |
| }); |
| it('should return only function call JSON if only function calls exist in parts', () => { |
| const func = { name: 'testFunc', args: { data: 'payload' } }; |
| const parts = [mockFunctionCallPart(func.name, func.args)]; |
| const expectedJson = JSON.stringify([func], null, 2); |
| expect(getStructuredResponseFromParts(parts)).toBe(expectedJson); |
| }); |
| it('should return text and function call JSON if both exist in parts', () => { |
| const text = 'Consider this data:'; |
| const func = { name: 'processData', args: { item: 42 } }; |
| const parts = [ |
| mockTextPart(text), |
| mockFunctionCallPart(func.name, func.args), |
| ]; |
| const expectedJson = JSON.stringify([func], null, 2); |
| expect(getStructuredResponseFromParts(parts)).toBe( |
| `${text}\n${expectedJson}`, |
| ); |
| }); |
| it('should return undefined if neither text nor function calls exist in parts', () => { |
| const parts: Part[] = []; |
| expect(getStructuredResponseFromParts(parts)).toBeUndefined(); |
| }); |
| }); |
| }); |
|
|
