diff --git a/.github/workflows/main.yaml b/.github/workflows/main.yaml index ba7a5322..6dccfe02 100644 --- a/.github/workflows/main.yaml +++ b/.github/workflows/main.yaml @@ -19,7 +19,7 @@ jobs: - uses: actions/checkout@v3 - uses: actions/setup-node@v3 with: - node-version: '18.x' + node-version: '22.x' - name: "Run checks" run: | npm ci @@ -81,7 +81,7 @@ jobs: # Setup .npmrc file to publish to npm - uses: actions/setup-node@v3 with: - node-version: '18.x' + node-version: '22.x' registry-url: 'https://registry.npmjs.org' - run: npm ci - run: npm run build diff --git a/ci/run_dependencies.sh b/ci/run_dependencies.sh index 68ed7ccc..24702631 100755 --- a/ci/run_dependencies.sh +++ b/ci/run_dependencies.sh @@ -21,18 +21,24 @@ function wait(){ echo "Waiting for $1" while true; do - if curl -s $1 > /dev/null; then + # first check if weaviate already responds + if ! curl -s $1 > /dev/null; then + continue + fi + + # endpoint available, check if it is ready + HTTP_STATUS=$(curl -s -o /dev/null -w "%{http_code}" "$1/v1/.well-known/ready") + + if [ "$HTTP_STATUS" -eq 200 ]; then break else - if [ $? -eq 7 ]; then - echo "Weaviate is not up yet. (waited for ${ALREADY_WAITING}s)" - if [ $ALREADY_WAITING -gt $MAX_WAIT_SECONDS ]; then - echo "Weaviate did not start up in $MAX_WAIT_SECONDS." - exit 1 - else - sleep 2 - let ALREADY_WAITING=$ALREADY_WAITING+2 - fi + echo "Weaviate is not up yet. (waited for ${ALREADY_WAITING}s)" + if [ $ALREADY_WAITING -gt $MAX_WAIT_SECONDS ]; then + echo "Weaviate did not start up in $MAX_WAIT_SECONDS." + exit 1 + else + sleep 2 + let ALREADY_WAITING=$ALREADY_WAITING+2 fi fi done diff --git a/src/collections/generate/index.ts b/src/collections/generate/index.ts index 065fae9d..38c1d1f4 100644 --- a/src/collections/generate/index.ts +++ b/src/collections/generate/index.ts @@ -3,10 +3,11 @@ import Connection from '../../connection/grpc.js'; import { ConsistencyLevel } from '../../data/index.js'; import { DbVersionSupport } from '../../utils/dbVersion.js'; -import { WeaviateInvalidInputError, WeaviateUnsupportedFeatureError } from '../../errors.js'; +import { WeaviateInvalidInputError } from '../../errors.js'; import { toBase64FromMedia } from '../../index.js'; import { SearchReply } from '../../proto/v1/search_get.js'; import { Deserialize } from '../deserialize/index.js'; +import { Check } from '../query/check.js'; import { BaseBm25Options, BaseHybridOptions, @@ -34,24 +35,10 @@ import { import { Generate } from './types.js'; class GenerateManager implements Generate { - private connection: Connection; - private name: string; - private dbVersionSupport: DbVersionSupport; - private consistencyLevel?: ConsistencyLevel; - private tenant?: string; + private check: Check; - private constructor( - connection: Connection, - name: string, - dbVersionSupport: DbVersionSupport, - consistencyLevel?: ConsistencyLevel, - tenant?: string - ) { - this.connection = connection; - this.name = name; - this.dbVersionSupport = dbVersionSupport; - this.consistencyLevel = consistencyLevel; - this.tenant = tenant; + private constructor(check: Check) { + this.check = check; } public static use( @@ -61,60 +48,11 @@ class GenerateManager implements Generate { consistencyLevel?: ConsistencyLevel, tenant?: string ): GenerateManager { - return new GenerateManager(connection, name, dbVersionSupport, consistencyLevel, tenant); + return new GenerateManager(new Check(connection, name, dbVersionSupport, consistencyLevel, tenant)); } - private checkSupportForNamedVectors = async (opts?: BaseNearOptions) => { - if (!Serialize.isNamedVectors(opts)) return; - const check = await this.dbVersionSupport.supportsNamedVectors(); - if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message); - }; - - private checkSupportForBm25AndHybridGroupByQueries = async (query: 'Bm25' | 'Hybrid', opts?: any) => { - if (!Serialize.isGroupBy(opts)) return; - const check = await this.dbVersionSupport.supportsBm25AndHybridGroupByQueries(); - if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message(query)); - }; - - private checkSupportForHybridNearTextAndNearVectorSubSearches = async (opts?: HybridOptions) => { - if (opts?.vector === undefined || Array.isArray(opts.vector)) return; - const check = await this.dbVersionSupport.supportsHybridNearTextAndNearVectorSubsearchQueries(); - if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message); - }; - - private checkSupportForMultiTargetVectorSearch = async (opts?: BaseNearOptions) => { - if (!Serialize.isMultiTargetVector(opts)) return false; - const check = await this.dbVersionSupport.supportsMultiTargetVectorSearch(); - if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message); - return check.supports; - }; - - private nearSearch = async (opts?: BaseNearOptions) => { - const [_, supportsTargets] = await Promise.all([ - this.checkSupportForNamedVectors(opts), - this.checkSupportForMultiTargetVectorSearch(opts), - ]); - return { - search: await this.connection.search(this.name, this.consistencyLevel, this.tenant), - supportsTargets, - }; - }; - - private hybridSearch = async (opts?: BaseHybridOptions) => { - const [supportsTargets] = await Promise.all([ - this.checkSupportForMultiTargetVectorSearch(opts), - this.checkSupportForNamedVectors(opts), - this.checkSupportForBm25AndHybridGroupByQueries('Hybrid', opts), - this.checkSupportForHybridNearTextAndNearVectorSubSearches(opts), - ]); - return { - search: await this.connection.search(this.name, this.consistencyLevel, this.tenant), - supportsTargets, - }; - }; - private async parseReply(reply: SearchReply) { - const deserialize = await Deserialize.use(this.dbVersionSupport); + const deserialize = await Deserialize.use(this.check.dbVersionSupport); return deserialize.generate(reply); } @@ -122,7 +60,7 @@ class GenerateManager implements Generate { opts: SearchOptions | GroupByOptions | undefined, reply: SearchReply ) { - const deserialize = await Deserialize.use(this.dbVersionSupport); + const deserialize = await Deserialize.use(this.check.dbVersionSupport); return Serialize.isGroupBy(opts) ? deserialize.generateGroupBy(reply) : deserialize.generate(reply); } @@ -130,9 +68,9 @@ class GenerateManager implements Generate { generate: GenerateOptions, opts?: FetchObjectsOptions ): Promise> { - return this.checkSupportForNamedVectors(opts) - .then(() => this.connection.search(this.name, this.consistencyLevel, this.tenant)) - .then((search) => + return this.check + .fetchObjects(opts) + .then(({ search }) => search.withFetch({ ...Serialize.fetchObjects(opts), generative: Serialize.generative(generate), @@ -152,12 +90,9 @@ class GenerateManager implements Generate { opts: GroupByBm25Options ): Promise>; public bm25(query: string, generate: GenerateOptions, opts?: Bm25Options): GenerateReturn { - return Promise.all([ - this.checkSupportForNamedVectors(opts), - this.checkSupportForBm25AndHybridGroupByQueries('Bm25', opts), - ]) - .then(() => this.connection.search(this.name, this.consistencyLevel, this.tenant)) - .then((search) => + return this.check + .bm25(opts) + .then(({ search }) => search.withBm25({ ...Serialize.bm25({ query, ...opts }), generative: Serialize.generative(generate), @@ -180,10 +115,17 @@ class GenerateManager implements Generate { opts: GroupByHybridOptions ): Promise>; public hybrid(query: string, generate: GenerateOptions, opts?: HybridOptions): GenerateReturn { - return this.hybridSearch(opts) - .then(({ search, supportsTargets }) => + return this.check + .hybridSearch(opts) + .then(({ search, supportsTargets, supportsVectorsForTargets, supportsWeightsForTargets }) => search.withHybrid({ - ...Serialize.hybrid({ query, supportsTargets, ...opts }), + ...Serialize.hybrid({ + query, + supportsTargets, + supportsVectorsForTargets, + supportsWeightsForTargets, + ...opts, + }), generative: Serialize.generative(generate), groupBy: Serialize.isGroupBy>(opts) ? Serialize.groupBy(opts.groupBy) @@ -208,11 +150,17 @@ class GenerateManager implements Generate { generate: GenerateOptions, opts?: NearOptions ): GenerateReturn { - return this.nearSearch(opts) - .then(({ search, supportsTargets }) => + return this.check + .nearSearch(opts) + .then(({ search, supportsTargets, supportsWeightsForTargets }) => toBase64FromMedia(image).then((image) => search.withNearImage({ - ...Serialize.nearImage({ image, supportsTargets, ...(opts ? opts : {}) }), + ...Serialize.nearImage({ + image, + supportsTargets, + supportsWeightsForTargets, + ...(opts ? opts : {}), + }), generative: Serialize.generative(generate), groupBy: Serialize.isGroupBy>(opts) ? Serialize.groupBy(opts.groupBy) @@ -234,10 +182,16 @@ class GenerateManager implements Generate { opts: GroupByNearOptions ): Promise>; public nearObject(id: string, generate: GenerateOptions, opts?: NearOptions): GenerateReturn { - return this.nearSearch(opts) - .then(({ search, supportsTargets }) => + return this.check + .nearSearch(opts) + .then(({ search, supportsTargets, supportsWeightsForTargets }) => search.withNearObject({ - ...Serialize.nearObject({ id, supportsTargets, ...(opts ? opts : {}) }), + ...Serialize.nearObject({ + id, + supportsTargets, + supportsWeightsForTargets, + ...(opts ? opts : {}), + }), generative: Serialize.generative(generate), groupBy: Serialize.isGroupBy>(opts) ? Serialize.groupBy(opts.groupBy) @@ -262,10 +216,16 @@ class GenerateManager implements Generate { generate: GenerateOptions, opts?: NearOptions ): GenerateReturn { - return this.nearSearch(opts) - .then(({ search, supportsTargets }) => + return this.check + .nearSearch(opts) + .then(({ search, supportsTargets, supportsWeightsForTargets }) => search.withNearText({ - ...Serialize.nearText({ query, supportsTargets, ...(opts ? opts : {}) }), + ...Serialize.nearText({ + query, + supportsTargets, + supportsWeightsForTargets, + ...(opts ? opts : {}), + }), generative: Serialize.generative(generate), groupBy: Serialize.isGroupBy>(opts) ? Serialize.groupBy(opts.groupBy) @@ -290,10 +250,17 @@ class GenerateManager implements Generate { generate: GenerateOptions, opts?: NearOptions ): GenerateReturn { - return this.nearSearch(opts) - .then(({ search, supportsTargets }) => + return this.check + .nearVector(vector, opts) + .then(({ search, supportsTargets, supportsVectorsForTargets, supportsWeightsForTargets }) => search.withNearVector({ - ...Serialize.nearVector({ vector, supportsTargets, ...(opts ? opts : {}) }), + ...Serialize.nearVector({ + vector, + supportsTargets, + supportsVectorsForTargets, + supportsWeightsForTargets, + ...(opts ? opts : {}), + }), generative: Serialize.generative(generate), groupBy: Serialize.isGroupBy>(opts) ? Serialize.groupBy(opts.groupBy) @@ -321,10 +288,15 @@ class GenerateManager implements Generate { generate: GenerateOptions, opts?: NearOptions ): GenerateReturn { - return this.nearSearch(opts) - .then(({ search, supportsTargets }) => { + return this.check + .nearSearch(opts) + .then(({ search, supportsTargets, supportsWeightsForTargets }) => { let reply: Promise; - const args = { supportsTargets, ...(opts ? opts : {}) }; + const args = { + supportsTargets, + supportsWeightsForTargets, + ...(opts ? opts : {}), + }; const generative = Serialize.generative(generate); const groupBy = Serialize.isGroupBy>(opts) ? Serialize.groupBy(opts.groupBy) diff --git a/src/collections/generate/integration.test.ts b/src/collections/generate/integration.test.ts index 93d722f2..1be98451 100644 --- a/src/collections/generate/integration.test.ts +++ b/src/collections/generate/integration.test.ts @@ -379,14 +379,11 @@ maybe('Testing of the collection.generate methods with a multi vector collection it('should generate with a near vector search on multi vectors', async () => { const query = () => collection.generate.nearVector( - [titleVector, title2Vector], + { title: titleVector, title2: title2Vector }, { groupedTask: 'What is the value of title here? {title}', groupedProperties: ['title'], singlePrompt: 'Write a haiku about ducks for {title}', - }, - { - targetVector: ['title', 'title2'], } ); if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { diff --git a/src/collections/query/check.ts b/src/collections/query/check.ts new file mode 100644 index 00000000..63f02b19 --- /dev/null +++ b/src/collections/query/check.ts @@ -0,0 +1,193 @@ +import Connection from '../../connection/grpc.js'; +import { WeaviateUnsupportedFeatureError } from '../../errors.js'; +import { ConsistencyLevel } from '../../index.js'; +import { DbVersionSupport } from '../../utils/dbVersion.js'; +import { GroupByOptions } from '../index.js'; +import { Serialize } from '../serialize/index.js'; +import { + BaseBm25Options, + BaseHybridOptions, + BaseNearOptions, + FetchObjectByIdOptions, + FetchObjectsOptions, + HybridNearTextSubSearch, + HybridNearVectorSubSearch, + HybridOptions, + NearVectorInputType, + SearchOptions, +} from './types.js'; + +export class Check { + private connection: Connection; + private name: string; + public dbVersionSupport: DbVersionSupport; + private consistencyLevel?: ConsistencyLevel; + private tenant?: string; + + public constructor( + connection: Connection, + name: string, + dbVersionSupport: DbVersionSupport, + consistencyLevel?: ConsistencyLevel, + tenant?: string + ) { + this.connection = connection; + this.name = name; + this.dbVersionSupport = dbVersionSupport; + this.consistencyLevel = consistencyLevel; + this.tenant = tenant; + } + + private getSearcher = () => this.connection.search(this.name, this.consistencyLevel, this.tenant); + + private checkSupportForNamedVectors = async (opts?: BaseNearOptions) => { + if (!Serialize.isNamedVectors(opts)) return; + const check = await this.dbVersionSupport.supportsNamedVectors(); + if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message); + }; + + private checkSupportForBm25AndHybridGroupByQueries = async ( + query: 'Bm25' | 'Hybrid', + opts?: SearchOptions | GroupByOptions + ) => { + if (!Serialize.isGroupBy(opts)) return; + const check = await this.dbVersionSupport.supportsBm25AndHybridGroupByQueries(); + if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message(query)); + }; + + private checkSupportForHybridNearTextAndNearVectorSubSearches = async (opts?: HybridOptions) => { + if (opts?.vector === undefined || Array.isArray(opts.vector)) return; + const check = await this.dbVersionSupport.supportsHybridNearTextAndNearVectorSubsearchQueries(); + if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message); + }; + + private checkSupportForMultiTargetSearch = async (opts?: BaseNearOptions) => { + if (!Serialize.isMultiTarget(opts)) return false; + const check = await this.dbVersionSupport.supportsMultiTargetVectorSearch(); + if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message); + return check.supports; + }; + + private checkSupportForMultiVectorSearch = async ( + vec?: NearVectorInputType | HybridNearVectorSubSearch | HybridNearTextSubSearch + ) => { + if (vec === undefined || Serialize.isHybridNearTextSearch(vec)) return false; + if (Serialize.isHybridNearVectorSearch(vec) && !Serialize.isMultiVector(vec.vector)) return false; + if (Serialize.isHybridVectorSearch(vec) && !Serialize.isMultiVector(vec)) return false; + const check = await this.dbVersionSupport.supportsMultiVectorSearch(); + if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message); + return check.supports; + }; + + private checkSupportForMultiWeightPerTargetSearch = async (opts?: BaseNearOptions) => { + if (!Serialize.isMultiWeightPerTarget(opts)) return false; + const check = await this.dbVersionSupport.supportsMultiWeightsPerTargetSearch(); + if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message); + return check.supports; + }; + + private checkSupportForMultiVectorPerTargetSearch = async ( + vec?: NearVectorInputType | HybridNearVectorSubSearch | HybridNearTextSubSearch + ) => { + if (vec === undefined || Serialize.isHybridNearTextSearch(vec)) return false; + if (Serialize.isHybridNearVectorSearch(vec) && !Serialize.isMultiVectorPerTarget(vec.vector)) + return false; + if (Serialize.isHybridVectorSearch(vec) && !Serialize.isMultiVectorPerTarget(vec)) return false; + const check = await this.dbVersionSupport.supportsMultiVectorPerTargetSearch(); + if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message); + return check.supports; + }; + + public nearSearch = (opts?: BaseNearOptions) => { + return Promise.all([ + this.getSearcher(), + this.checkSupportForMultiTargetSearch(opts), + this.checkSupportForMultiWeightPerTargetSearch(opts), + this.checkSupportForNamedVectors(opts), + ]).then(([search, supportsTargets, supportsWeightsForTargets]) => { + const is126 = supportsTargets; + const is127 = supportsWeightsForTargets; + return { search, supportsTargets: is126 || is127, supportsWeightsForTargets: is127 }; + }); + }; + + public nearVector = (vec: NearVectorInputType, opts?: BaseNearOptions) => { + return Promise.all([ + this.getSearcher(), + this.checkSupportForMultiTargetSearch(opts), + this.checkSupportForMultiVectorSearch(vec), + this.checkSupportForMultiVectorPerTargetSearch(vec), + this.checkSupportForMultiWeightPerTargetSearch(opts), + this.checkSupportForNamedVectors(opts), + ]).then( + ([ + search, + supportsMultiTarget, + supportsMultiVector, + supportsVectorsForTargets, + supportsWeightsForTargets, + ]) => { + const is126 = supportsMultiTarget || supportsMultiVector; + const is127 = supportsVectorsForTargets || supportsWeightsForTargets; + return { + search, + supportsTargets: is126 || is127, + supportsVectorsForTargets: is127, + supportsWeightsForTargets: is127, + }; + } + ); + }; + + public hybridSearch = (opts?: BaseHybridOptions) => { + return Promise.all([ + this.getSearcher(), + this.checkSupportForMultiTargetSearch(opts), + this.checkSupportForMultiVectorSearch(opts?.vector), + this.checkSupportForMultiVectorPerTargetSearch(opts?.vector), + this.checkSupportForMultiWeightPerTargetSearch(opts), + this.checkSupportForNamedVectors(opts), + this.checkSupportForBm25AndHybridGroupByQueries('Hybrid', opts), + this.checkSupportForHybridNearTextAndNearVectorSubSearches(opts), + ]).then( + ([ + search, + supportsMultiTarget, + supportsMultiVector, + supportsWeightsForTargets, + supportsVectorsForTargets, + ]) => { + const is126 = supportsMultiTarget || supportsMultiVector; + const is127 = supportsVectorsForTargets || supportsWeightsForTargets; + return { + search, + supportsTargets: is126 || is127, + supportsWeightsForTargets: is127, + supportsVectorsForTargets: is127, + }; + } + ); + }; + + public fetchObjects = (opts?: FetchObjectsOptions) => { + return Promise.all([this.getSearcher(), this.checkSupportForNamedVectors(opts)]).then(([search]) => { + return { search }; + }); + }; + + public fetchObjectById = (opts?: FetchObjectByIdOptions) => { + return Promise.all([this.getSearcher(), this.checkSupportForNamedVectors(opts)]).then(([search]) => { + return { search }; + }); + }; + + public bm25 = (opts?: BaseBm25Options) => { + return Promise.all([ + this.getSearcher(), + this.checkSupportForNamedVectors(opts), + this.checkSupportForBm25AndHybridGroupByQueries('Bm25', opts), + ]).then(([search]) => { + return { search }; + }); + }; +} diff --git a/src/collections/query/index.ts b/src/collections/query/index.ts index d261f9a9..5a6c93f2 100644 --- a/src/collections/query/index.ts +++ b/src/collections/query/index.ts @@ -10,7 +10,8 @@ import { Deserialize } from '../deserialize/index.js'; import { Serialize } from '../serialize/index.js'; import { GroupByOptions, GroupByReturn, WeaviateObject, WeaviateReturn } from '../types/index.js'; -import { WeaviateInvalidInputError, WeaviateUnsupportedFeatureError } from '../../errors.js'; +import { WeaviateInvalidInputError } from '../../errors.js'; +import { Check } from './check.js'; import { BaseBm25Options, BaseHybridOptions, @@ -34,24 +35,10 @@ import { } from './types.js'; class QueryManager implements Query { - private connection: Connection; - private name: string; - private dbVersionSupport: DbVersionSupport; - private consistencyLevel?: ConsistencyLevel; - private tenant?: string; + private check: Check; - private constructor( - connection: Connection, - name: string, - dbVersionSupport: DbVersionSupport, - consistencyLevel?: ConsistencyLevel, - tenant?: string - ) { - this.connection = connection; - this.name = name; - this.dbVersionSupport = dbVersionSupport; - this.consistencyLevel = consistencyLevel; - this.tenant = tenant; + private constructor(check: Check) { + this.check = check; } public static use( @@ -61,63 +48,11 @@ class QueryManager implements Query { consistencyLevel?: ConsistencyLevel, tenant?: string ): QueryManager { - return new QueryManager(connection, name, dbVersionSupport, consistencyLevel, tenant); + return new QueryManager(new Check(connection, name, dbVersionSupport, consistencyLevel, tenant)); } - private checkSupportForNamedVectors = async (opts?: BaseNearOptions) => { - if (!Serialize.isNamedVectors(opts)) return; - const check = await this.dbVersionSupport.supportsNamedVectors(); - if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message); - }; - - private checkSupportForBm25AndHybridGroupByQueries = async ( - query: 'Bm25' | 'Hybrid', - opts?: SearchOptions | GroupByOptions - ) => { - if (!Serialize.isGroupBy(opts)) return; - const check = await this.dbVersionSupport.supportsBm25AndHybridGroupByQueries(); - if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message(query)); - }; - - private checkSupportForHybridNearTextAndNearVectorSubSearches = async (opts?: HybridOptions) => { - if (opts?.vector === undefined || Array.isArray(opts.vector)) return; - const check = await this.dbVersionSupport.supportsHybridNearTextAndNearVectorSubsearchQueries(); - if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message); - }; - - private checkSupportForMultiTargetVectorSearch = async (opts?: BaseNearOptions) => { - if (!Serialize.isMultiTargetVector(opts)) return false; - const check = await this.dbVersionSupport.supportsMultiTargetVectorSearch(); - if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message); - return check.supports; - }; - - private nearSearch = async (opts?: BaseNearOptions) => { - const [supportsTargets] = await Promise.all([ - this.checkSupportForMultiTargetVectorSearch(opts), - this.checkSupportForNamedVectors(opts), - ]); - return { - search: await this.connection.search(this.name, this.consistencyLevel, this.tenant), - supportsTargets, - }; - }; - - private hybridSearch = async (opts?: BaseHybridOptions) => { - const [supportsTargets] = await Promise.all([ - this.checkSupportForMultiTargetVectorSearch(opts), - this.checkSupportForNamedVectors(opts), - this.checkSupportForBm25AndHybridGroupByQueries('Hybrid', opts), - this.checkSupportForHybridNearTextAndNearVectorSubSearches(opts), - ]); - return { - search: await this.connection.search(this.name, this.consistencyLevel, this.tenant), - supportsTargets, - }; - }; - private async parseReply(reply: SearchReply) { - const deserialize = await Deserialize.use(this.dbVersionSupport); + const deserialize = await Deserialize.use(this.check.dbVersionSupport); return deserialize.query(reply); } @@ -125,34 +60,31 @@ class QueryManager implements Query { opts: SearchOptions | GroupByOptions | undefined, reply: SearchReply ) { - const deserialize = await Deserialize.use(this.dbVersionSupport); + const deserialize = await Deserialize.use(this.check.dbVersionSupport); return Serialize.isGroupBy(opts) ? deserialize.groupBy(reply) : deserialize.query(reply); } public fetchObjectById(id: string, opts?: FetchObjectByIdOptions): Promise | null> { - return this.checkSupportForNamedVectors(opts) - .then(() => this.connection.search(this.name, this.consistencyLevel, this.tenant)) - .then((search) => search.withFetch(Serialize.fetchObjectById({ id, ...opts }))) + return this.check + .fetchObjectById(opts) + .then(({ search }) => search.withFetch(Serialize.fetchObjectById({ id, ...opts }))) .then((reply) => this.parseReply(reply)) .then((ret) => (ret.objects.length === 1 ? ret.objects[0] : null)); } public fetchObjects(opts?: FetchObjectsOptions): Promise> { - return this.checkSupportForNamedVectors(opts) - .then(() => this.connection.search(this.name, this.consistencyLevel, this.tenant)) - .then((search) => search.withFetch(Serialize.fetchObjects(opts))) + return this.check + .fetchObjects(opts) + .then(({ search }) => search.withFetch(Serialize.fetchObjects(opts))) .then((reply) => this.parseReply(reply)); } public bm25(query: string, opts?: BaseBm25Options): Promise>; public bm25(query: string, opts: GroupByBm25Options): Promise>; public bm25(query: string, opts?: Bm25Options): QueryReturn { - return Promise.all([ - this.checkSupportForNamedVectors(opts), - this.checkSupportForBm25AndHybridGroupByQueries('Bm25', opts), - ]) - .then(() => this.connection.search(this.name, this.consistencyLevel, this.tenant)) - .then((search) => + return this.check + .bm25(opts) + .then(({ search }) => search.withBm25({ ...Serialize.bm25({ query, ...opts }), groupBy: Serialize.isGroupBy>(opts) @@ -166,10 +98,17 @@ class QueryManager implements Query { public hybrid(query: string, opts?: BaseHybridOptions): Promise>; public hybrid(query: string, opts: GroupByHybridOptions): Promise>; public hybrid(query: string, opts?: HybridOptions): QueryReturn { - return this.hybridSearch(opts) - .then(({ search, supportsTargets }) => + return this.check + .hybridSearch(opts) + .then(({ search, supportsTargets, supportsWeightsForTargets, supportsVectorsForTargets }) => search.withHybrid({ - ...Serialize.hybrid({ query, supportsTargets, ...opts }), + ...Serialize.hybrid({ + query, + supportsTargets, + supportsVectorsForTargets, + supportsWeightsForTargets, + ...opts, + }), groupBy: Serialize.isGroupBy>(opts) ? Serialize.groupBy(opts.groupBy) : undefined, @@ -181,11 +120,17 @@ class QueryManager implements Query { public nearImage(image: string | Buffer, opts?: BaseNearOptions): Promise>; public nearImage(image: string | Buffer, opts: GroupByNearOptions): Promise>; public nearImage(image: string | Buffer, opts?: NearOptions): QueryReturn { - return this.nearSearch(opts) - .then(({ search, supportsTargets }) => { + return this.check + .nearSearch(opts) + .then(({ search, supportsTargets, supportsWeightsForTargets }) => { return toBase64FromMedia(image).then((image) => search.withNearImage({ - ...Serialize.nearImage({ image, supportsTargets, ...(opts ? opts : {}) }), + ...Serialize.nearImage({ + image, + supportsTargets, + supportsWeightsForTargets, + ...(opts ? opts : {}), + }), groupBy: Serialize.isGroupBy>(opts) ? Serialize.groupBy(opts.groupBy) : undefined, @@ -206,9 +151,14 @@ class QueryManager implements Query { opts: GroupByNearOptions ): Promise>; public nearMedia(media: string | Buffer, type: NearMediaType, opts?: NearOptions): QueryReturn { - return this.nearSearch(opts) - .then(({ search, supportsTargets }) => { - const args = { supportsTargets, ...(opts ? opts : {}) }; + return this.check + .nearSearch(opts) + .then(({ search, supportsTargets, supportsWeightsForTargets }) => { + const args = { + supportsTargets, + supportsWeightsForTargets, + ...(opts ? opts : {}), + }; let reply: Promise; switch (type) { case 'audio': @@ -252,10 +202,16 @@ class QueryManager implements Query { public nearObject(id: string, opts?: BaseNearOptions): Promise>; public nearObject(id: string, opts: GroupByNearOptions): Promise>; public nearObject(id: string, opts?: NearOptions): QueryReturn { - return this.nearSearch(opts) - .then(({ search, supportsTargets }) => + return this.check + .nearSearch(opts) + .then(({ search, supportsTargets, supportsWeightsForTargets }) => search.withNearObject({ - ...Serialize.nearObject({ id, supportsTargets, ...(opts ? opts : {}) }), + ...Serialize.nearObject({ + id, + supportsTargets, + supportsWeightsForTargets, + ...(opts ? opts : {}), + }), groupBy: Serialize.isGroupBy>(opts) ? Serialize.groupBy(opts.groupBy) : undefined, @@ -267,10 +223,16 @@ class QueryManager implements Query { public nearText(query: string | string[], opts?: BaseNearTextOptions): Promise>; public nearText(query: string | string[], opts: GroupByNearTextOptions): Promise>; public nearText(query: string | string[], opts?: NearTextOptions): QueryReturn { - return this.nearSearch(opts) - .then(({ search, supportsTargets }) => + return this.check + .nearSearch(opts) + .then(({ search, supportsTargets, supportsWeightsForTargets }) => search.withNearText({ - ...Serialize.nearText({ query, supportsTargets, ...(opts ? opts : {}) }), + ...Serialize.nearText({ + query, + supportsTargets, + supportsWeightsForTargets, + ...(opts ? opts : {}), + }), groupBy: Serialize.isGroupBy>(opts) ? Serialize.groupBy(opts.groupBy) : undefined, @@ -282,10 +244,17 @@ class QueryManager implements Query { public nearVector(vector: NearVectorInputType, opts?: BaseNearOptions): Promise>; public nearVector(vector: NearVectorInputType, opts: GroupByNearOptions): Promise>; public nearVector(vector: NearVectorInputType, opts?: NearOptions): QueryReturn { - return this.nearSearch(opts) - .then(({ search, supportsTargets }) => + return this.check + .nearVector(vector, opts) + .then(({ search, supportsTargets, supportsVectorsForTargets, supportsWeightsForTargets }) => search.withNearVector({ - ...Serialize.nearVector({ vector, supportsTargets, ...(opts ? opts : {}) }), + ...Serialize.nearVector({ + vector, + supportsTargets, + supportsVectorsForTargets, + supportsWeightsForTargets, + ...(opts ? opts : {}), + }), groupBy: Serialize.isGroupBy>(opts) ? Serialize.groupBy(opts.groupBy) : undefined, diff --git a/src/collections/query/integration.test.ts b/src/collections/query/integration.test.ts index 37de616f..49a2e236 100644 --- a/src/collections/query/integration.test.ts +++ b/src/collections/query/integration.test.ts @@ -365,7 +365,7 @@ describe('Testing of the collection.query methods with a collection with a refer ).toEqual('test'); }); - it.skip('should query with nearObject returning the referenced object', async () => { + it('should query with nearObject returning the referenced object', async () => { const ret = await collection.query.nearObject(id2, { returnProperties: ['testProp'], returnReferences: [ @@ -417,271 +417,363 @@ describe('Testing of the collection.query methods with a collection with a refer ).toEqual('test'); }); }); +}); + +describe('Testing of the collection.query methods with a collection with a nested property', () => { + let client: WeaviateClient; + let collection: Collection; + const collectionName = 'TestCollectionQueryWithNestedProps'; - describe('Testing of the collection.query methods with a collection with a nested property', () => { - let client: WeaviateClient; - let collection: Collection; - const collectionName = 'TestCollectionQueryWithNestedProps'; - - let id1: string; - let id2: string; - - type TestCollectionQueryWithNestedProps = { - testProp: string; - nestedProp?: { - one: string; - two: string; - again?: { - three: string; - }; - onceMore?: { - four: string; - }; + let id1: string; + let id2: string; + + type TestCollectionQueryWithNestedProps = { + testProp: string; + nestedProp?: { + one: string; + two: string; + again?: { + three: string; + }; + onceMore?: { + four: string; }; }; + }; - afterAll(() => { - return client.collections.delete(collectionName).catch((err) => { - console.error(err); - throw err; + afterAll(() => { + return client.collections.delete(collectionName).catch((err) => { + console.error(err); + throw err; + }); + }); + + beforeAll(async () => { + client = await weaviate.connectToLocal(); + collection = client.collections.get(collectionName); + return client.collections + .create({ + name: collectionName, + properties: [ + { + name: 'testProp', + dataType: 'text', + vectorizePropertyName: false, + }, + { + name: 'nestedProp', + dataType: 'object', + vectorizePropertyName: false, + nestedProperties: [ + { + name: 'one', + dataType: 'text', + }, + { + name: 'two', + dataType: 'text', + }, + { + name: 'again', + dataType: 'object', + nestedProperties: [ + { + name: 'three', + dataType: 'text', + }, + ], + }, + { + name: 'onceMore', + dataType: 'object', + nestedProperties: [ + { + name: 'four', + dataType: 'text', + }, + ], + }, + ], + }, + ], + vectorizers: weaviate.configure.vectorizer.text2VecContextionary(), + }) + .then(async () => { + id1 = await collection.data.insert({ + properties: { + testProp: 'test', + }, + }); + id2 = await collection.data.insert({ + properties: { + testProp: 'other', + nestedProp: { + one: 'test', + two: 'test', + again: { + three: 'test', + }, + onceMore: { + four: 'test', + }, + }, + }, + }); }); + }); + + it('should query without searching returning the nested object', async () => { + const ret = await collection.query.fetchObjects({ + returnProperties: [ + 'testProp', + { + name: 'nestedProp', + properties: [ + 'one', + { + name: 'again', + properties: ['three'], + }, + { + name: 'onceMore', + properties: ['four'], + }, + ], + }, + ], + }); + ret.objects.sort((a, b) => a.properties.testProp.localeCompare(b.properties.testProp)); + expect(ret.objects.length).toEqual(2); + expect(ret.objects[0].properties.testProp).toEqual('other'); + expect(ret.objects[0].properties.nestedProp?.one).toEqual('test'); + expect(ret.objects[0].properties.nestedProp?.two).toBeUndefined(); + expect(ret.objects[0].properties.nestedProp?.again?.three).toEqual('test'); + expect(ret.objects[0].properties.nestedProp?.onceMore?.four).toEqual('test'); + expect(ret.objects[1].properties.testProp).toEqual('test'); + expect(ret.objects[1].properties.nestedProp).toBeUndefined(); + }); +}); + +describe('Testing of the collection.query methods with a collection with a multiple vectors', () => { + let client: WeaviateClient; + let collection: Collection; + const collectionName = 'TestCollectionQueryWithMultiVector'; + + let id1: string; + let id2: string; + + type TestCollectionQueryWithMultiVector = { + title: string; + }; + + afterAll(() => { + return client.collections.delete(collectionName).catch((err) => { + console.error(err); + throw err; }); + }); - beforeAll(async () => { - client = await weaviate.connectToLocal(); - collection = client.collections.get(collectionName); - return client.collections - .create({ + beforeAll(async () => { + client = await weaviate.connectToLocal(); + collection = client.collections.get(collectionName); + const query = () => + client.collections + .create({ name: collectionName, properties: [ { - name: 'testProp', + name: 'title', dataType: 'text', vectorizePropertyName: false, }, - { - name: 'nestedProp', - dataType: 'object', - vectorizePropertyName: false, - nestedProperties: [ - { - name: 'one', - dataType: 'text', - }, - { - name: 'two', - dataType: 'text', - }, - { - name: 'again', - dataType: 'object', - nestedProperties: [ - { - name: 'three', - dataType: 'text', - }, - ], - }, - { - name: 'onceMore', - dataType: 'object', - nestedProperties: [ - { - name: 'four', - dataType: 'text', - }, - ], - }, - ], - }, ], - vectorizers: weaviate.configure.vectorizer.text2VecContextionary(), + vectorizers: [ + weaviate.configure.vectorizer.text2VecContextionary({ + name: 'title', + sourceProperties: ['title'], + }), + weaviate.configure.vectorizer.text2VecContextionary({ + name: 'title2', + sourceProperties: ['title'], + }), + ], }) .then(async () => { id1 = await collection.data.insert({ properties: { - testProp: 'test', + title: 'test', }, }); id2 = await collection.data.insert({ properties: { - testProp: 'other', - nestedProp: { - one: 'test', - two: 'test', - again: { - three: 'test', - }, - onceMore: { - four: 'test', - }, - }, + title: 'other', }, }); }); - }); + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 24, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + return query(); + }); - it('should query without searching returning the nested object', async () => { - const ret = await collection.query.fetchObjects({ - returnProperties: [ - 'testProp', - { - name: 'nestedProp', - properties: [ - 'one', - { - name: 'again', - properties: ['three'], - }, - { - name: 'onceMore', - properties: ['four'], - }, - ], - }, - ], + it('should query returning a named vector', async () => { + const query = () => + collection.query.fetchObjects({ + returnProperties: ['title'], + includeVector: ['title'], }); - ret.objects.sort((a, b) => a.properties.testProp.localeCompare(b.properties.testProp)); - expect(ret.objects.length).toEqual(2); - expect(ret.objects[0].properties.testProp).toEqual('other'); - expect(ret.objects[0].properties.nestedProp?.one).toEqual('test'); - expect(ret.objects[0].properties.nestedProp?.two).toBeUndefined(); - expect(ret.objects[0].properties.nestedProp?.again?.three).toEqual('test'); - expect(ret.objects[0].properties.nestedProp?.onceMore?.four).toEqual('test'); - expect(ret.objects[1].properties.testProp).toEqual('test'); - expect(ret.objects[1].properties.nestedProp).toBeUndefined(); - }); + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 24, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + ret.objects.sort((a, b) => a.properties.title.localeCompare(b.properties.title)); + expect(ret.objects.length).toEqual(2); + expect(ret.objects[0].properties.title).toEqual('other'); + expect(ret.objects[0].vectors.title).toBeDefined(); + expect(ret.objects[1].properties.title).toEqual('test'); + expect(ret.objects[1].vectors.title).toBeDefined(); }); - describe('Testing of the collection.query methods with a collection with a multiple vectors', () => { - let client: WeaviateClient; - let collection: Collection; - const collectionName = 'TestCollectionQueryWithMultiVector'; - - let id1: string; - let id2: string; - - type TestCollectionQueryWithMultiVector = { - title: string; - }; + it('should query without searching returning a named vector', async () => { + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 24, 0))) { + return; + } + const ret = await collection.query.fetchObjects({ + returnProperties: ['title'], + includeVector: ['title'], + }); + ret.objects.sort((a, b) => a.properties.title.localeCompare(b.properties.title)); + expect(ret.objects.length).toEqual(2); + expect(ret.objects[0].properties.title).toEqual('other'); + expect(ret.objects[0].vectors.title).toBeDefined(); + expect(ret.objects[1].properties.title).toEqual('test'); + expect(ret.objects[1].vectors.title).toBeDefined(); + }); - afterAll(() => { - return client.collections.delete(collectionName).catch((err) => { - console.error(err); - throw err; - }); + it('should query with a vector search over the named vector space', async () => { + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 24, 0))) { + return; + } + const ret = await collection.query.nearObject(id1, { + returnProperties: ['title'], + targetVector: 'title', }); + expect(ret.objects.length).toEqual(2); + expect(ret.objects[0].properties.title).toEqual('test'); + expect(ret.objects[1].properties.title).toEqual('other'); + }); - beforeAll(async () => { - client = await weaviate.connectToLocal(); - collection = client.collections.get(collectionName); - const query = () => - client.collections - .create({ - name: collectionName, - properties: [ - { - name: 'title', - dataType: 'text', - vectorizePropertyName: false, - }, - ], - vectorizers: [ - weaviate.configure.vectorizer.text2VecContextionary({ - name: 'title', - sourceProperties: ['title'], - }), - weaviate.configure.vectorizer.text2VecContextionary({ - name: 'title2', - sourceProperties: ['title'], - }), - ], - }) - .then(async () => { - id1 = await collection.data.insert({ - properties: { - title: 'test', - }, - }); - id2 = await collection.data.insert({ - properties: { - title: 'other', - }, - }); - }); - if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 24, 0))) { - await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); - return; - } - return query(); + it('should query a nearObject multi-target vector search over the named vector spaces', async () => { + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { + return; + } + const ret = await collection.query.nearObject(id1, { + returnProperties: ['title'], + targetVector: ['title', 'title2'], }); + expect(ret.objects.length).toEqual(2); + expect(ret.objects[0].properties.title).toEqual('test'); + expect(ret.objects[1].properties.title).toEqual('other'); + }); - it('should query returning a named vector', async () => { - const query = () => - collection.query.fetchObjects({ - returnProperties: ['title'], - includeVector: ['title'], - }); - if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 24, 0))) { - await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); - return; - } - const ret = await query(); - ret.objects.sort((a, b) => a.properties.title.localeCompare(b.properties.title)); - expect(ret.objects.length).toEqual(2); - expect(ret.objects[0].properties.title).toEqual('other'); - expect(ret.objects[0].vectors.title).toBeDefined(); - expect(ret.objects[1].properties.title).toEqual('test'); - expect(ret.objects[1].vectors.title).toBeDefined(); + it('should group-by query a nearObject multi-target vector search over the named vector spaces', async () => { + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { + return; + } + const ret = await collection.query.nearObject(id1, { + returnProperties: ['title'], + targetVector: ['title', 'title2'], + groupBy: { + numberOfGroups: 2, + objectsPerGroup: 1, + property: 'title', + }, }); + expect(ret.objects.length).toEqual(2); + expect(ret.objects[0].belongsToGroup).toEqual('test'); + expect(ret.objects[1].belongsToGroup).toEqual('other'); + }); - it('should query without searching returning a named vector', async () => { - if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 24, 0))) { - return; - } - const ret = await collection.query.fetchObjects({ + it('should query a weighted multi-target nearObject vector search over the named vector spaces', async () => { + const query = () => + collection.query.nearObject(id1, { + distance: 0.01, returnProperties: ['title'], - includeVector: ['title'], + targetVector: collection.multiTargetVector.manualWeights({ + title: 5, + title2: 0.1, + }), }); - ret.objects.sort((a, b) => a.properties.title.localeCompare(b.properties.title)); - expect(ret.objects.length).toEqual(2); - expect(ret.objects[0].properties.title).toEqual('other'); - expect(ret.objects[0].vectors.title).toBeDefined(); - expect(ret.objects[1].properties.title).toEqual('test'); - expect(ret.objects[1].vectors.title).toBeDefined(); - }); + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + expect(ret.objects.length).toEqual(1); + expect(ret.objects[0].properties.title).toEqual('test'); + }); - it('should query with a vector search over the named vector space', async () => { - if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 24, 0))) { - return; - } - const ret = await collection.query.nearObject(id1, { + it('should query a weighted multi-target nearObject vector search with multiple weights over the named vector spaces', async () => { + const query = () => + collection.query.nearObject(id1, { + distance: 0.01, returnProperties: ['title'], - targetVector: 'title', + targetVector: collection.multiTargetVector.manualWeights({ + title: 5, + title2: [0.1, 0.2], + }), }); - expect(ret.objects.length).toEqual(2); - expect(ret.objects[0].properties.title).toEqual('test'); - expect(ret.objects[1].properties.title).toEqual('other'); - }); + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 27, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + expect(ret.objects.length).toEqual(1); + expect(ret.objects[0].properties.title).toEqual('test'); + }); - it('should query a multi-target vector search over the named vector spaces', async () => { - if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { - return; - } - const ret = await collection.query.nearObject(id1, { + it('should group-by query a weighted multi-target nearObject vector search over the named vector spaces', async () => { + const query = () => + collection.query.nearObject(id1, { + returnProperties: ['title'], + targetVector: collection.multiTargetVector.sum(['title', 'title2']), + groupBy: { + numberOfGroups: 2, + objectsPerGroup: 1, + property: 'title', + }, + }); + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + expect(ret.objects.length).toEqual(2); + expect(ret.objects[0].belongsToGroup).toEqual('test'); + expect(ret.objects[1].belongsToGroup).toEqual('other'); + }); + + it('should perform a hybrid query over the named vector spaces', async () => { + const query = () => + collection.query.hybrid('test', { returnProperties: ['title'], targetVector: ['title', 'title2'], }); - expect(ret.objects.length).toEqual(2); - expect(ret.objects[0].properties.title).toEqual('test'); - expect(ret.objects[1].properties.title).toEqual('other'); - }); + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + expect(ret.objects.length).toEqual(2); + expect(ret.objects[0].properties.title).toEqual('test'); + expect(ret.objects[1].properties.title).toEqual('other'); + }); - it('should group-by query a multi-target vector search over the named vector spaces', async () => { - if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { - return; - } - const ret = await collection.query.nearObject(id1, { + it('should perform a group-by hybrid query over the named vector spaces', async () => { + const query = () => + collection.query.hybrid('test', { returnProperties: ['title'], targetVector: ['title', 'title2'], groupBy: { @@ -690,103 +782,280 @@ describe('Testing of the collection.query methods with a collection with a refer property: 'title', }, }); - expect(ret.objects.length).toEqual(2); - expect(ret.objects[0].belongsToGroup).toEqual('test'); - expect(ret.objects[1].belongsToGroup).toEqual('other'); - }); + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + expect(ret.objects.length).toEqual(2); + expect(ret.objects[0].belongsToGroup).toEqual('test'); + expect(ret.objects[1].belongsToGroup).toEqual('other'); + }); - it('should query a weighted multi-target vector search over the named vector spaces', async () => { - const query = () => - collection.query.nearObject(id1, { - distance: 0.01, - returnProperties: ['title'], - targetVector: collection.multiTargetVector.manualWeights({ - title: 5, - title2: 0.1, - }), - }); - if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { - await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); - return; - } - const ret = await query(); - expect(ret.objects.length).toEqual(1); - expect(ret.objects[0].properties.title).toEqual('test'); - }); + it('should perform a weighted sum hybrid query over the named vector spaces', async () => { + const query = () => + collection.query.hybrid('test', { + returnProperties: ['title'], + targetVector: collection.multiTargetVector.sum(['title', 'title2']), + }); + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + expect(ret.objects.length).toEqual(2); + expect(ret.objects[0].properties.title).toEqual('test'); + expect(ret.objects[1].properties.title).toEqual('other'); + }); - it('should group-by query a weighted multi-target vector search over the named vector spaces', async () => { - const query = () => - collection.query.nearObject(id1, { - returnProperties: ['title'], - targetVector: collection.multiTargetVector.sum(['title', 'title2']), - groupBy: { - numberOfGroups: 2, - objectsPerGroup: 1, - property: 'title', + it('should perform a multi-vector hybrid search over the named vector spaces', async () => { + const two = await collection.query.fetchObjectById(id2, { includeVector: true }); + + const query = () => + collection.query.hybrid('', { + alpha: 1, + returnProperties: ['title'], + vector: { + title: two?.vectors.title!, + title2: two?.vectors.title2!, + }, + }); + + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + expect(ret.objects.length).toEqual(2); + expect(ret.objects[0].properties.title).toEqual('other'); + expect(ret.objects[1].properties.title).toEqual('test'); + }); + + it('should perform a multi-vector hybrid search over the named vector spaces with a combination', async () => { + const two = await collection.query.fetchObjectById(id2, { includeVector: true }); + + const query = () => + collection.query.hybrid('', { + alpha: 1, + returnProperties: ['title'], + vector: { + title: two?.vectors.title!, + title2: two?.vectors.title2!, + }, + targetVector: collection.multiTargetVector.sum(['title', 'title2']), + }); + + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + expect(ret.objects.length).toEqual(2); + expect(ret.objects[0].properties.title).toEqual('other'); + expect(ret.objects[1].properties.title).toEqual('test'); + }); + + it('should perform a multi-vector hybrid nearVector subsearch over the named vector spaces', async () => { + const two = await collection.query.fetchObjectById(id2, { includeVector: true }); + + const query = () => + collection.query.hybrid('', { + alpha: 1, + returnProperties: ['title'], + vector: { + vector: { + title: two?.vectors.title!, + title2: two?.vectors.title2!, }, - }); - if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { - await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); - return; - } - const ret = await query(); - expect(ret.objects.length).toEqual(2); - expect(ret.objects[0].belongsToGroup).toEqual('test'); - expect(ret.objects[1].belongsToGroup).toEqual('other'); - }); + }, + }); - it('should perform a hybrid query over the named vector spaces', async () => { - const query = () => - collection.query.hybrid('test', { - returnProperties: ['title'], - targetVector: ['title', 'title2'], - }); - if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { - await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); - return; - } - const ret = await query(); - expect(ret.objects.length).toEqual(2); - expect(ret.objects[0].properties.title).toEqual('test'); - expect(ret.objects[1].properties.title).toEqual('other'); - }); + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + expect(ret.objects.length).toEqual(2); + expect(ret.objects[0].properties.title).toEqual('other'); + expect(ret.objects[1].properties.title).toEqual('test'); + }); - it('should perform a group-by hybrid query over the named vector spaces', async () => { - const query = () => - collection.query.hybrid('test', { - returnProperties: ['title'], - targetVector: ['title', 'title2'], - groupBy: { - numberOfGroups: 2, - objectsPerGroup: 1, - property: 'title', + it('should perform a multi-vector hybrid nearVector subsearch over the named vector spaces with combination', async () => { + const two = await collection.query.fetchObjectById(id2, { includeVector: true }); + + const query = () => + collection.query.hybrid('', { + alpha: 1, + returnProperties: ['title'], + vector: { + vector: { + title: two?.vectors.title!, + title2: two?.vectors.title2!, }, - }); - if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { - await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); - return; - } - const ret = await query(); - expect(ret.objects.length).toEqual(2); - expect(ret.objects[0].belongsToGroup).toEqual('test'); - expect(ret.objects[1].belongsToGroup).toEqual('other'); - }); + }, + targetVector: collection.multiTargetVector.sum(['title', 'title2']), + }); - it('should perform a weighted hybrid query over the named vector spaces', async () => { - const query = () => - collection.query.hybrid('test', { + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + expect(ret.objects.length).toEqual(2); + expect(ret.objects[0].properties.title).toEqual('other'); + expect(ret.objects[1].properties.title).toEqual('test'); + }); + + it('should perform a multi-vector-per-target hybrid nearVector subsearch over the named vector spaces without weights', async () => { + const one = await collection.query.fetchObjectById(id1, { includeVector: true }); + const two = await collection.query.fetchObjectById(id2, { includeVector: true }); + + const query = () => + collection.query.hybrid('', { + alpha: 1, + returnProperties: ['title'], + vector: { + vector: { + title: [one?.vectors.title!, two?.vectors.title!], + }, + }, + }); + + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 27, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + expect(ret.objects.length).toEqual(2); + }); + + it('should perform a multi-vector-per-target hybrid nearVector subsearch over the named vector spaces with weights', async () => { + const one = await collection.query.fetchObjectById(id1, { includeVector: true }); + const two = await collection.query.fetchObjectById(id2, { includeVector: true }); + + const query = () => + collection.query.hybrid('', { + alpha: 1, + returnProperties: ['title'], + vector: { + vector: { + title: [one?.vectors.title!, two?.vectors.title!], + }, + }, + targetVector: collection.multiTargetVector.manualWeights({ + title: [0.1, 0.9], + }), + }); + + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 27, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + expect(ret.objects.length).toEqual(2); + expect(ret.objects[0].properties.title).toEqual('other'); + expect(ret.objects[1].properties.title).toEqual('test'); + }); + + it('should perform a multi-vector-per-target hybrid search over the named vector spaces', async () => { + const one = await collection.query.fetchObjectById(id1, { includeVector: true }); + const two = await collection.query.fetchObjectById(id2, { includeVector: true }); + + const query = () => + collection.query.hybrid('', { + alpha: 1, + returnProperties: ['title'], + vector: { + title: [one?.vectors.title!, two?.vectors.title!], + }, + }); + + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 27, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + expect(ret.objects.length).toEqual(2); + }); + + it('should perform a multi-vector-per-target hybrid search with weights over the named vector spaces', async () => { + const one = await collection.query.fetchObjectById(id1, { includeVector: true }); + const two = await collection.query.fetchObjectById(id2, { includeVector: true }); + + const query = () => + collection.query.hybrid('', { + alpha: 1, + returnProperties: ['title'], + vector: { + title: [one?.vectors.title!, two?.vectors.title!], + }, + targetVector: collection.multiTargetVector.manualWeights({ + title: [0.1, 0.9], + }), + }); + + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 27, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + expect(ret.objects.length).toEqual(2); + // We are weighted the second vector higher, so we expect the second object to be returned first + expect(ret.objects[0].properties.title).toEqual('other'); + expect(ret.objects[1].properties.title).toEqual('test'); + }); + + it('should perform a nearVector vector search over two named vector spaces', async () => { + const one = await collection.query.fetchObjectById(id1, { includeVector: true }); + + const query = () => + collection.query.nearVector( + { + title: one?.vectors.title!, + title2: one?.vectors.title2!, + }, + { returnProperties: ['title'], - targetVector: collection.multiTargetVector.sum(['title', 'title2']), - }); - if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { - await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); - return; - } - const ret = await query(); - expect(ret.objects.length).toEqual(2); - expect(ret.objects[0].properties.title).toEqual('test'); - expect(ret.objects[1].properties.title).toEqual('other'); - }); + } + ); + + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 26, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + expect(ret.objects.length).toEqual(2); + // Since no bm25, the order is not guaranteed since we're searching on both vectors equally + expect(ret.objects[0].properties.title).toEqual('test'); + expect(ret.objects[1].properties.title).toEqual('other'); + }); + + it('should perform a multi-vector-per-target nearVector search over one named vector with weights', async () => { + const one = await collection.query.fetchObjectById(id1, { includeVector: true }); + const two = await collection.query.fetchObjectById(id2, { includeVector: true }); + + const query = () => + collection.query.nearVector( + { + title: [one?.vectors.title!, two?.vectors.title!], + }, + { + returnProperties: ['title'], + targetVector: collection.multiTargetVector.manualWeights({ + title: [0.1, 0.9], + }), + } + ); + + if (await client.getWeaviateVersion().then((ver) => ver.isLowerThan(1, 27, 0))) { + await expect(query()).rejects.toThrow(WeaviateUnsupportedFeatureError); + return; + } + const ret = await query(); + expect(ret.objects.length).toEqual(2); + // We are weighted the second vector higher, so we expect the second object to be returned first + expect(ret.objects[0].properties.title).toEqual('other'); + expect(ret.objects[1].properties.title).toEqual('test'); }); }); @@ -901,7 +1170,7 @@ describe('Testing of the groupBy collection.query methods with a simple collecti expect(ret.objects[0].belongsToGroup).toEqual('test'); }); - it.skip('should groupBy with nearObject', async () => { + it('should groupBy with nearObject', async () => { const ret = await collection.query.nearObject(id, { groupBy: groupByArgs, }); diff --git a/src/collections/query/types.ts b/src/collections/query/types.ts index 2e7aa621..83080d21 100644 --- a/src/collections/query/types.ts +++ b/src/collections/query/types.ts @@ -175,15 +175,11 @@ export type GroupByNearTextOptions = BaseNearTextOptions & { export type NearMediaType = 'audio' | 'depth' | 'image' | 'imu' | 'thermal' | 'video'; /** - * The vector(s) to search for in the `query.nearVector` method. One of: + * The vector(s) to search for in the `query/generate.nearVector` and `query/generate.hybrid` methods. One of: * - a single vector, in which case pass a single number array. - * - multiple unnamed vectors, in which case pass an array of number arrays. - * - multiple named vectors, in which case pass an object of type `Record`. - * - * If you pass multiple unnamed vectors here then you must specify the names of the vector spaces in the `targetVector` parameter. - * If these two arrays are of different lengths, the method will throw an error. + * - multiple named vectors, in which case pass an object of type `Record`. */ -export type NearVectorInputType = number[] | number[][] | Record; +export type NearVectorInputType = number[] | Record; /** * Over which vector spaces to perform the vector search query in the `nearX` search method. One of: @@ -240,7 +236,7 @@ interface Hybrid { * * This overload is for performing a search without the `groupBy` param. * - * @param {string} query - The query to search for. + * @param {string} query - The query to search for in the BM25 keyword search.. * @param {BaseHybridOptions} [opts] - The available options for the search excluding the `groupBy` param. * @returns {Promise>} - The result of the search within the fetched collection. */ @@ -252,7 +248,7 @@ interface Hybrid { * * This overload is for performing a search with the `groupBy` param. * - * @param {string} query - The query to search for. + * @param {string} query - The query to search for in the BM25 keyword search.. * @param {GroupByHybridOptions} opts - The available options for the search including the `groupBy` param. * @returns {Promise>} - The result of the search within the fetched collection. */ @@ -264,7 +260,7 @@ interface Hybrid { * * This overload is for performing a search with a programmatically defined `opts` param. * - * @param {string} query - The query to search for. + * @param {string} query - The query to search for in the BM25 keyword search.. * @param {HybridOptions} [opts] - The available options for the search including the `groupBy` param. * @returns {Promise>} - The result of the search within the fetched collection. */ diff --git a/src/collections/query/utils.ts b/src/collections/query/utils.ts index 74629068..4bbe9f76 100644 --- a/src/collections/query/utils.ts +++ b/src/collections/query/utils.ts @@ -6,12 +6,17 @@ export class NearVectorInputGuards { return Array.isArray(input) && input.length > 0 && !Array.isArray(input[0]); } - public static is2DArray(input: NearVectorInputType): input is number[][] { - return Array.isArray(input) && input.length > 0 && Array.isArray(input[0]); + public static isObject(input: NearVectorInputType): input is Record { + return !Array.isArray(input); } +} - public static isObject(input: NearVectorInputType): input is Record { - return !Array.isArray(input); +export class ArrayInputGuards { + public static is1DArray(input: U | T): input is T { + return Array.isArray(input) && input.length > 0 && !Array.isArray(input[0]); + } + public static is2DArray(input: U | T): input is T { + return Array.isArray(input) && input.length > 0 && Array.isArray(input[0]); } } @@ -25,6 +30,7 @@ export class TargetVectorInputGuards { } public static isMultiJoin(input: TargetVectorInputType): input is MultiTargetVectorJoin { - return (input as MultiTargetVectorJoin).combination !== undefined; + const i = input as MultiTargetVectorJoin; + return i.combination !== undefined && i.targetVectors !== undefined; } } diff --git a/src/collections/serialize/index.ts b/src/collections/serialize/index.ts index 83265af6..81e80365 100644 --- a/src/collections/serialize/index.ts +++ b/src/collections/serialize/index.ts @@ -6,10 +6,10 @@ import { BatchObject_Properties, BatchObject_SingleTargetRefProps, } from '../../proto/v1/batch.js'; +import { GenerativeSearch } from '../../proto/v1/generative.js'; import { BM25, CombinationMethod, - GenerativeSearch, GroupBy, Hybrid, Hybrid_FusionType, @@ -29,9 +29,15 @@ import { Rerank, SortBy as SortByGrpc, Targets, + VectorForTarget, + WeightsForTarget, } from '../../proto/v1/search_get.js'; -import { WeaviateInvalidInputError, WeaviateSerializationError } from '../../errors.js'; +import { + WeaviateInvalidInputError, + WeaviateSerializationError, + WeaviateUnsupportedFeatureError, +} from '../../errors.js'; import { BaseSearchArgs, SearchBm25Args, @@ -85,7 +91,7 @@ import { SearchOptions, TargetVectorInputType, } from '../query/types.js'; -import { NearVectorInputGuards, TargetVectorInputGuards } from '../query/utils.js'; +import { ArrayInputGuards, NearVectorInputGuards, TargetVectorInputGuards } from '../query/utils.js'; import { ReferenceGuards } from '../references/classes.js'; import { Beacon } from '../references/index.js'; import { uuidToBeacon } from '../references/utils.js'; @@ -318,10 +324,31 @@ export class Serialize { return Array.isArray(opts?.includeVector) || opts?.targetVector !== undefined; }; - public static isMultiTargetVector = (opts?: BaseNearOptions): boolean => { + public static isMultiTarget = (opts?: BaseNearOptions): boolean => { return opts?.targetVector !== undefined && !TargetVectorInputGuards.isSingle(opts.targetVector); }; + public static isMultiWeightPerTarget = (opts?: BaseNearOptions): boolean => { + return ( + opts?.targetVector !== undefined && + TargetVectorInputGuards.isMultiJoin(opts.targetVector) && + opts.targetVector.weights !== undefined && + Object.values(opts.targetVector.weights).some(ArrayInputGuards.is1DArray) + ); + }; + + public static isMultiVector = (vec?: NearVectorInputType): boolean => { + return ( + vec !== undefined && + !Array.isArray(vec) && + Object.values(vec).some(ArrayInputGuards.is1DArray || ArrayInputGuards.is2DArray) + ); + }; + + public static isMultiVectorPerTarget = (vec?: NearVectorInputType): boolean => { + return vec !== undefined && !Array.isArray(vec) && Object.values(vec).some(ArrayInputGuards.is2DArray); + }; + private static common = (args?: SearchOptions): BaseSearchArgs => { const out: BaseSearchArgs = { limit: args?.limit, @@ -382,19 +409,23 @@ export class Serialize { }; }; - private static isHybridVectorSearch = ( + public static isHybridVectorSearch = ( vector: BaseHybridOptions['vector'] - ): vector is number[] | number[][] | Record => { - return !Serialize.isHybridNearTextSearch(vector) && !Serialize.isHybridNearVectorSearch(vector); + ): vector is number[] | Record => { + return ( + vector !== undefined && + !Serialize.isHybridNearTextSearch(vector) && + !Serialize.isHybridNearVectorSearch(vector) + ); }; - private static isHybridNearTextSearch = ( + public static isHybridNearTextSearch = ( vector: BaseHybridOptions['vector'] ): vector is HybridNearTextSubSearch => { return (vector as HybridNearTextSubSearch)?.query !== undefined; }; - private static isHybridNearVectorSearch = ( + public static isHybridNearVectorSearch = ( vector: BaseHybridOptions['vector'] ): vector is HybridNearVectorSubSearch => { return (vector as HybridNearVectorSubSearch)?.vector !== undefined; @@ -402,14 +433,29 @@ export class Serialize { private static hybridVector = (args: { supportsTargets: boolean; + supportsVectorsForTargets: boolean; + supportsWeightsForTargets: boolean; vector?: BaseHybridOptions['vector']; }) => { const vector = args.vector; if (Serialize.isHybridVectorSearch(vector)) { - const { targets, targetVectors, vectorBytes } = Serialize.vectors({ ...args, vector: vector }); - return { vectorBytes, targetVectors, targets }; + const { targets, targetVectors, vectorBytes, vectorPerTarget, vectorForTargets } = Serialize.vectors({ + ...args, + argumentName: 'vector', + vector: vector, + }); + return vectorBytes !== undefined + ? { vectorBytes, targetVectors, targets } + : { + targetVectors, + targets, + nearVector: NearVector.fromPartial({ + vectorForTargets, + vectorPerTarget, + }), + }; } else if (Serialize.isHybridNearTextSearch(vector)) { - const { targetVectors, targets } = Serialize.vectors({ ...args, vector: undefined }); + const { targetVectors, targets } = Serialize.targetVector(args); return { targets, targetVectors, @@ -422,8 +468,9 @@ export class Serialize { }), }; } else if (Serialize.isHybridNearVectorSearch(vector)) { - const { targetVectors, targets, vectorBytes, vectorPerTarget } = Serialize.vectors({ + const { targetVectors, targets, vectorBytes, vectorPerTarget, vectorForTargets } = Serialize.vectors({ ...args, + argumentName: 'vector', vector: vector.vector, }); return { @@ -434,6 +481,7 @@ export class Serialize { distance: vector.distance, vectorBytes, vectorPerTarget, + vectorForTargets, }), }; } else { @@ -443,7 +491,12 @@ export class Serialize { }; public static hybrid = ( - args: { query: string; supportsTargets: boolean } & HybridOptions + args: { + query: string; + supportsTargets: boolean; + supportsVectorsForTargets: boolean; + supportsWeightsForTargets: boolean; + } & HybridOptions ): SearchHybridArgs => { const fusionType = (fusionType?: string): Hybrid_FusionType => { switch (fusionType) { @@ -474,7 +527,7 @@ export class Serialize { }; public static nearAudio = ( - args: { audio: string; supportsTargets: boolean } & NearOptions + args: { audio: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions ): SearchNearAudioArgs => { const { targets, targetVectors } = Serialize.targetVector(args); return { @@ -491,7 +544,7 @@ export class Serialize { }; public static nearDepth = ( - args: { depth: string; supportsTargets: boolean } & NearOptions + args: { depth: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions ): SearchNearDepthArgs => { const { targets, targetVectors } = Serialize.targetVector(args); return { @@ -508,7 +561,7 @@ export class Serialize { }; public static nearImage = ( - args: { image: string; supportsTargets: boolean } & NearOptions + args: { image: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions ): SearchNearImageArgs => { const { targets, targetVectors } = Serialize.targetVector(args); return { @@ -525,7 +578,7 @@ export class Serialize { }; public static nearIMU = ( - args: { imu: string; supportsTargets: boolean } & NearOptions + args: { imu: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions ): SearchNearIMUArgs => { const { targets, targetVectors } = Serialize.targetVector(args); return { @@ -542,7 +595,7 @@ export class Serialize { }; public static nearObject = ( - args: { id: string; supportsTargets: boolean } & NearOptions + args: { id: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions ): SearchNearObjectArgs => { const { targets, targetVectors } = Serialize.targetVector(args); return { @@ -561,6 +614,7 @@ export class Serialize { private static nearTextSearch = (args: { query: string | string[]; supportsTargets: boolean; + supportsWeightsForTargets: boolean; targetVector?: TargetVectorInputType; certainty?: number; distance?: number; @@ -592,7 +646,11 @@ export class Serialize { }; public static nearText = ( - args: { query: string | string[]; supportsTargets: boolean } & NearTextOptions + args: { + query: string | string[]; + supportsTargets: boolean; + supportsWeightsForTargets: boolean; + } & NearTextOptions ): SearchNearTextArgs => { return { ...Serialize.common(args), @@ -602,7 +660,7 @@ export class Serialize { }; public static nearThermal = ( - args: { thermal: string; supportsTargets: boolean } & NearOptions + args: { thermal: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions ): SearchNearThermalArgs => { const { targets, targetVectors } = Serialize.targetVector(args); return { @@ -625,11 +683,16 @@ export class Serialize { private static nearVectorSearch = (args: { vector: NearVectorInputType; supportsTargets: boolean; + supportsVectorsForTargets: boolean; + supportsWeightsForTargets: boolean; certainty?: number; distance?: number; targetVector?: TargetVectorInputType; }) => { - const { targetVectors, targets, vectorBytes, vectorPerTarget } = Serialize.vectors(args); + const { targetVectors, targets, vectorBytes, vectorPerTarget, vectorForTargets } = Serialize.vectors({ + ...args, + argumentName: 'nearVector', + }); return NearVector.fromPartial({ certainty: args.certainty, distance: args.distance, @@ -637,11 +700,13 @@ export class Serialize { targets, vectorPerTarget, vectorBytes, + vectorForTargets, }); }; - private static targetVector = (args: { + public static targetVector = (args: { supportsTargets: boolean; + supportsWeightsForTargets: boolean; targetVector?: TargetVectorInputType; }): { targets?: Targets; targetVectors?: string[] } => { if (args.targetVector === undefined) { @@ -663,45 +728,97 @@ export class Serialize { } : { targetVectors: args.targetVector }; } else { - return { targets: Serialize.targets(args.targetVector) }; + return { targets: Serialize.targets(args.targetVector, args.supportsWeightsForTargets) }; } }; private static vectors = (args: { supportsTargets: boolean; + supportsVectorsForTargets: boolean; + supportsWeightsForTargets: boolean; + argumentName: 'nearVector' | 'vector'; targetVector?: TargetVectorInputType; vector?: NearVectorInputType; - }) => { - const invalidNearVectorError = new WeaviateInvalidInputError(`near vector argument can be: - - an array of numbers - - an array of arrays of numbers for multi target search - - an object with target names as keys and arrays of numbers as values - received: ${args.vector}`); + }): { + targetVectors?: string[]; + targets?: Targets; + vectorBytes?: Uint8Array; + vectorPerTarget?: Record; + vectorForTargets?: VectorForTarget[]; + } => { + const invalidVectorError = + new WeaviateInvalidInputError(`${args.argumentName} argument must be populated and: + - an array of numbers (number[]) + - an object with target names as keys and 1D and/or 2D arrays of numbers (number[] or number[][]) as values + received: ${args.vector} and ${args.targetVector}`); - const { targets, targetVectors } = Serialize.targetVector(args); if (args.vector === undefined) { - return { targetVectors, targets }; + return Serialize.targetVector(args); } if (NearVectorInputGuards.isObject(args.vector)) { - if (targets === undefined || targets.targetVectors.length != Object.keys(args.vector).length) { - throw new WeaviateInvalidInputError( - 'The number of target vectors must be equal to the number of search vectors.' - ); + if (Object.keys(args.vector).length === 0) { + throw invalidVectorError; + } + if (args.supportsVectorsForTargets) { + const vectorForTargets: VectorForTarget[] = Object.entries(args.vector) + .map(([target, vector]) => { + return { + target, + vector: vector, + }; + }) + .reduce((acc, { target, vector }) => { + return ArrayInputGuards.is2DArray(vector) + ? acc.concat(vector.map((v) => ({ name: target, vectorBytes: Serialize.vectorToBytes(v) }))) + : acc.concat([{ name: target, vectorBytes: Serialize.vectorToBytes(vector) }]); + }, [] as VectorForTarget[]); + return args.targetVector !== undefined + ? { + ...Serialize.targetVector(args), + vectorForTargets, + } + : { + targetVectors: undefined, + targets: Targets.fromPartial({ + targetVectors: vectorForTargets.map((v) => v.name), + }), + vectorForTargets, + }; + } else { + const vectorPerTarget: Record = {}; + Object.entries(args.vector).forEach(([k, v]) => { + if (ArrayInputGuards.is2DArray(v)) { + return; + } + vectorPerTarget[k] = Serialize.vectorToBytes(v); + }); + if (args.targetVector !== undefined) { + const { targets, targetVectors } = Serialize.targetVector(args); + return { + targetVectors, + targets, + vectorPerTarget, + }; + } else { + return args.supportsTargets + ? { + targets: Targets.fromPartial({ + targetVectors: Object.keys(vectorPerTarget), + }), + vectorPerTarget, + } + : { + targetVectors: Object.keys(vectorPerTarget), + vectorPerTarget, + }; + } } - const vectorPerTarget: Record = {}; - Object.entries(args.vector).forEach(([k, v]) => { - vectorPerTarget[k] = Serialize.vectorToBytes(v); - }); - return { - targetVectors, - targets, - vectorPerTarget, - }; } else { if (args.vector.length === 0) { - throw invalidNearVectorError; + throw invalidVectorError; } if (NearVectorInputGuards.is1DArray(args.vector)) { + const { targetVectors, targets } = Serialize.targetVector(args); const vectorBytes = Serialize.vectorToBytes(args.vector); return { targetVectors, @@ -709,27 +826,19 @@ export class Serialize { vectorBytes, }; } - if (NearVectorInputGuards.is2DArray(args.vector)) { - if (targets === undefined || targets.targetVectors.length != args.vector.length) { - throw new WeaviateInvalidInputError( - 'The number of target vectors must be equal to the number of search vectors.' - ); - } - const vectorPerTarget: Record = {}; - args.vector.forEach((v, i) => { - vectorPerTarget[targets.targetVectors[i]] = Serialize.vectorToBytes(v); - }); - return { - targetVectors, - targets, - vectorPerTarget, - }; - } - throw invalidNearVectorError; + throw invalidVectorError; } }; - private static targets = (targets: MultiTargetVectorJoin) => { + private static targets = ( + targets: MultiTargetVectorJoin, + supportsWeightsForTargets: boolean + ): { + combination: CombinationMethod; + targetVectors: string[]; + weights: Record; + weightsForTargets: WeightsForTarget[]; + } => { let combination: CombinationMethod; switch (targets.combination) { case 'sum': @@ -750,15 +859,54 @@ export class Serialize { default: throw new Error('Invalid combination method'); } - return { - combination, - targetVectors: targets.targetVectors, - weights: targets.weights ? targets.weights : {}, - }; + if (targets.weights !== undefined && supportsWeightsForTargets) { + const weightsForTargets: WeightsForTarget[] = Object.entries(targets.weights) + .map(([target, weight]) => { + return { + target, + weight, + }; + }) + .reduce((acc, { target, weight }) => { + return Array.isArray(weight) + ? acc.concat(weight.map((w) => ({ target, weight: w }))) + : acc.concat([{ target, weight }]); + }, [] as WeightsForTarget[]); + return { + combination, + targetVectors: weightsForTargets.map((w) => w.target), + weights: {}, + weightsForTargets, + }; + } else if (targets.weights !== undefined && !supportsWeightsForTargets) { + if (Object.values(targets.weights).some((v) => Array.isArray(v))) { + throw new WeaviateUnsupportedFeatureError( + 'Multiple weights per target are not supported in this Weaviate version. Please upgrade to at least Weaviate 1.27.0.' + ); + } + return { + combination, + targetVectors: targets.targetVectors, + weights: targets.weights as Record, // TS can't type narrow the complicated .some predicate above + weightsForTargets: [], + }; + } else { + return { + combination, + targetVectors: targets.targetVectors, + weights: {}, + weightsForTargets: [], + }; + } }; public static nearVector = ( - args: { vector: NearVectorInputType; supportsTargets: boolean } & NearOptions + args: { + vector: NearVectorInputType; + supportsTargets: boolean; + supportsVectorsForTargets: boolean; + supportsWeightsForTargets: boolean; + } & NearOptions ): SearchNearVectorArgs => { return { ...Serialize.common(args), @@ -768,7 +916,7 @@ export class Serialize { }; public static nearVideo = ( - args: { video: string; supportsTargets: boolean } & NearOptions + args: { video: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions ): SearchNearVideoArgs => { const { targets, targetVectors } = Serialize.targetVector(args); return { diff --git a/src/collections/serialize/unit.test.ts b/src/collections/serialize/unit.test.ts index b6805394..4b3eae72 100644 --- a/src/collections/serialize/unit.test.ts +++ b/src/collections/serialize/unit.test.ts @@ -13,9 +13,10 @@ import { SearchNearVideoArgs, } from '../../grpc/searcher.js'; import { Filters, Filters_Operator } from '../../proto/v1/base.js'; +import { GenerativeSearch } from '../../proto/v1/generative.js'; import { BM25, - GenerativeSearch, + CombinationMethod, GroupBy, Hybrid, Hybrid_FusionType, @@ -31,12 +32,15 @@ import { NearVector, NearVideoSearch, PropertiesRequest, + Targets, } from '../../proto/v1/search_get.js'; import { Filters as FiltersFactory } from '../filters/classes.js'; import filter from '../filters/index.js'; +import { TargetVectorInputType } from '../query/types.js'; import { Reference } from '../references/index.js'; import sort from '../sort/index.js'; import { WeaviateField } from '../types/index.js'; +import multiTargetVector from '../vectors/multiTargetVector.js'; import { DataGuards, Serialize } from './index.js'; describe('Unit testing of Serialize', () => { @@ -142,7 +146,7 @@ describe('Unit testing of Serialize', () => { }); }); - it('should parse args for hybrid', () => { + it('should parse args for simple hybrid', () => { const args = Serialize.hybrid({ query: 'test', queryProperties: ['name'], @@ -151,6 +155,8 @@ describe('Unit testing of Serialize', () => { targetVector: 'title', fusionType: 'Ranked', supportsTargets: false, + supportsVectorsForTargets: false, + supportsWeightsForTargets: false, }); expect(args).toEqual({ hybridSearch: Hybrid.fromPartial({ @@ -165,6 +171,60 @@ describe('Unit testing of Serialize', () => { }); }); + it('should parse args for multi-vector & multi-target hybrid', () => { + const args = Serialize.hybrid({ + query: 'test', + queryProperties: ['name'], + alpha: 0.6, + vector: { + title: [ + [1, 2, 3], + [4, 5, 6], + ], + description: [7, 8, 9], + }, + targetVector: multiTargetVector().manualWeights({ title: [0.5, 0.5], description: 0.5 }), + fusionType: 'Ranked', + supportsTargets: true, + supportsVectorsForTargets: true, + supportsWeightsForTargets: true, + }); + expect(args).toEqual({ + hybridSearch: Hybrid.fromPartial({ + query: 'test', + properties: ['name'], + alpha: 0.6, + nearVector: NearVector.fromPartial({ + vectorForTargets: [ + { name: 'title', vectorBytes: new Uint8Array(new Float32Array([1, 2, 3]).buffer) }, + { name: 'title', vectorBytes: new Uint8Array(new Float32Array([4, 5, 6]).buffer) }, + { name: 'description', vectorBytes: new Uint8Array(new Float32Array([7, 8, 9]).buffer) }, + ], + }), + targets: Targets.fromPartial({ + combination: CombinationMethod.COMBINATION_METHOD_TYPE_MANUAL, + targetVectors: ['title', 'title', 'description'], + weightsForTargets: [ + { + target: 'title', + weight: 0.5, + }, + { + target: 'title', + weight: 0.5, + }, + { + target: 'description', + weight: 0.5, + }, + ], + }), + fusionType: Hybrid_FusionType.FUSION_TYPE_RANKED, + }), + metadata: MetadataRequest.fromPartial({ uuid: true }), + }); + }); + it('should parse args for nearAudio', () => { const args = Serialize.nearAudio({ audio: 'audio', @@ -172,6 +232,7 @@ describe('Unit testing of Serialize', () => { distance: 0.4, targetVector: 'audio', supportsTargets: false, + supportsWeightsForTargets: false, }); expect(args).toEqual({ nearAudio: NearAudioSearch.fromPartial({ @@ -188,6 +249,7 @@ describe('Unit testing of Serialize', () => { const args = Serialize.nearDepth({ depth: 'depth', supportsTargets: false, + supportsWeightsForTargets: false, }); expect(args).toEqual({ nearDepth: NearDepthSearch.fromPartial({ @@ -201,6 +263,7 @@ describe('Unit testing of Serialize', () => { const args = Serialize.nearIMU({ imu: 'imu', supportsTargets: false, + supportsWeightsForTargets: false, }); expect(args).toEqual({ nearIMU: NearIMUSearch.fromPartial({ @@ -214,6 +277,7 @@ describe('Unit testing of Serialize', () => { const args = Serialize.nearImage({ image: 'image', supportsTargets: false, + supportsWeightsForTargets: false, }); expect(args).toEqual({ nearImage: NearImageSearch.fromPartial({ @@ -227,6 +291,7 @@ describe('Unit testing of Serialize', () => { const args = Serialize.nearObject({ id: 'id', supportsTargets: false, + supportsWeightsForTargets: false, }); expect(args).toEqual({ nearObject: NearObject.fromPartial({ @@ -250,6 +315,7 @@ describe('Unit testing of Serialize', () => { force: 0.6, }, supportsTargets: false, + supportsWeightsForTargets: false, }); expect(args).toEqual({ nearText: NearTextSearch.fromPartial({ @@ -273,6 +339,7 @@ describe('Unit testing of Serialize', () => { const args = Serialize.nearThermal({ thermal: 'thermal', supportsTargets: false, + supportsWeightsForTargets: false, }); expect(args).toEqual({ nearThermal: NearThermalSearch.fromPartial({ @@ -282,10 +349,12 @@ describe('Unit testing of Serialize', () => { }); }); - it('should parse args for nearVector', () => { + it('should parse args for nearVector with single vector', () => { const args = Serialize.nearVector({ vector: [1, 2, 3], supportsTargets: false, + supportsVectorsForTargets: false, + supportsWeightsForTargets: false, }); expect(args).toEqual({ nearVector: NearVector.fromPartial({ @@ -295,10 +364,59 @@ describe('Unit testing of Serialize', () => { }); }); + it('should parse args for nearVector with two named vectors and supportsTargets (<1.27.0)', () => { + const args = Serialize.nearVector({ + vector: { + a: [1, 2, 3], + b: [4, 5, 6], + }, + supportsTargets: true, + supportsVectorsForTargets: false, + supportsWeightsForTargets: false, + }); + expect(args).toEqual({ + nearVector: NearVector.fromPartial({ + vectorPerTarget: { + a: new Uint8Array(new Float32Array([1, 2, 3]).buffer), + b: new Uint8Array(new Float32Array([4, 5, 6]).buffer), + }, + targets: { targetVectors: ['a', 'b'] }, + }), + metadata: MetadataRequest.fromPartial({ uuid: true }), + }); + }); + + it('should parse args for nearVector with two named vectors and all supports (==1.27.x)', () => { + const args = Serialize.nearVector({ + vector: { + a: [ + [1, 2, 3], + [4, 5, 6], + ], + b: [7, 8, 9], + }, + supportsTargets: true, + supportsVectorsForTargets: true, + supportsWeightsForTargets: true, + }); + expect(args).toEqual({ + nearVector: NearVector.fromPartial({ + vectorForTargets: [ + { name: 'a', vectorBytes: new Uint8Array(new Float32Array([1, 2, 3]).buffer) }, + { name: 'a', vectorBytes: new Uint8Array(new Float32Array([4, 5, 6]).buffer) }, + { name: 'b', vectorBytes: new Uint8Array(new Float32Array([7, 8, 9]).buffer) }, + ], + targets: { targetVectors: ['a', 'a', 'b'] }, + }), + metadata: MetadataRequest.fromPartial({ uuid: true }), + }); + }); + it('should parse args for nearVideo', () => { const args = Serialize.nearVideo({ video: 'video', supportsTargets: false, + supportsWeightsForTargets: false, }); expect(args).toEqual({ nearVideo: NearVideoSearch.fromPartial({ @@ -318,6 +436,8 @@ describe('Unit testing of Serialize', () => { singleResponsePrompt: 'test', groupedProperties: ['name'], groupedResponseTask: 'testing', + single: undefined, + grouped: undefined, }); }); @@ -491,6 +611,177 @@ describe('Unit testing of Serialize', () => { }); }); + it('should parse isMultiWeightPerTarget', () => { + expect( + Serialize.isMultiWeightPerTarget({ + targetVector: 'a', + }) + ).toEqual(false); + expect( + Serialize.isMultiWeightPerTarget({ + targetVector: ['a'], + }) + ).toEqual(false); + expect( + Serialize.isMultiWeightPerTarget({ + targetVector: multiTargetVector().manualWeights({ a: 0.5, b: 0.5 }), + }) + ).toEqual(false); + expect( + Serialize.isMultiWeightPerTarget({ + targetVector: multiTargetVector().manualWeights({ a: [0.5, 0.5], b: 0.5 }), + }) + ).toEqual(true); + }); + + describe('should parse TargetVectorInput type', () => { + type Out = { + targets?: Targets; + targetVectors?: string[]; + }; + type Test = { + name: string; + targetVector: TargetVectorInputType; + supportsTargets: boolean; + supportsWeightsForTargets: boolean; + out: Out; + }; + const tests: Test[] = [ + { + name: 'should parse single target vector into targets', + targetVector: 'a', + supportsTargets: true, + supportsWeightsForTargets: false, + out: { + targets: Targets.fromPartial({ targetVectors: ['a'] }), + }, + }, + { + name: 'should parse list of target vectors into targets', + targetVector: ['a', 'b'], + supportsTargets: true, + supportsWeightsForTargets: false, + out: { + targets: Targets.fromPartial({ targetVectors: ['a', 'b'] }), + }, + }, + { + name: 'should parse MultiTargetJoin sum', + targetVector: multiTargetVector().average(['a', 'b']), + supportsTargets: true, + supportsWeightsForTargets: false, + out: { + targets: Targets.fromPartial({ + combination: CombinationMethod.COMBINATION_METHOD_TYPE_AVERAGE, + targetVectors: ['a', 'b'], + }), + }, + }, + { + name: 'should parse MultiTargetJoin manual single weight per target', + targetVector: multiTargetVector().manualWeights({ a: 0.5, b: 0.5 }), + supportsTargets: true, + supportsWeightsForTargets: false, + out: { + targets: Targets.fromPartial({ + combination: CombinationMethod.COMBINATION_METHOD_TYPE_MANUAL, + targetVectors: ['a', 'b'], + weights: { a: 0.5, b: 0.5 }, + }), + }, + }, + { + name: 'should parse MultiTargetJoin manual multiple weights per target', + targetVector: multiTargetVector().manualWeights({ a: [0.5, 0.5], b: 0.5 }), + supportsTargets: true, + supportsWeightsForTargets: true, + out: { + targets: Targets.fromPartial({ + combination: CombinationMethod.COMBINATION_METHOD_TYPE_MANUAL, + targetVectors: ['a', 'a', 'b'], + weightsForTargets: [ + { target: 'a', weight: 0.5 }, + { target: 'a', weight: 0.5 }, + { target: 'b', weight: 0.5 }, + ], + }), + }, + }, + { + name: 'should parse MultiTargetJoin minimum', + targetVector: multiTargetVector().minimum(['a', 'b']), + supportsTargets: true, + supportsWeightsForTargets: false, + out: { + targets: Targets.fromPartial({ + combination: CombinationMethod.COMBINATION_METHOD_TYPE_MIN, + targetVectors: ['a', 'b'], + }), + }, + }, + { + name: 'should parse MultiTargetJoin sum', + targetVector: multiTargetVector().average(['a', 'b']), + supportsTargets: true, + supportsWeightsForTargets: false, + out: { + targets: Targets.fromPartial({ + combination: CombinationMethod.COMBINATION_METHOD_TYPE_AVERAGE, + targetVectors: ['a', 'b'], + }), + }, + }, + { + name: 'should parse MultiTargetJoin relativeScore single weight per target', + targetVector: multiTargetVector().relativeScore({ a: 0.5, b: 0.5 }), + supportsTargets: true, + supportsWeightsForTargets: false, + out: { + targets: Targets.fromPartial({ + combination: CombinationMethod.COMBINATION_METHOD_TYPE_RELATIVE_SCORE, + targetVectors: ['a', 'b'], + weights: { a: 0.5, b: 0.5 }, + }), + }, + }, + { + name: 'should parse MultiTargetJoin relativeScore multiple weights per target', + targetVector: multiTargetVector().relativeScore({ a: [0.5, 0.5], b: 0.5 }), + supportsTargets: true, + supportsWeightsForTargets: true, + out: { + targets: Targets.fromPartial({ + combination: CombinationMethod.COMBINATION_METHOD_TYPE_RELATIVE_SCORE, + targetVectors: ['a', 'a', 'b'], + weightsForTargets: [ + { target: 'a', weight: 0.5 }, + { target: 'a', weight: 0.5 }, + { target: 'b', weight: 0.5 }, + ], + }), + }, + }, + { + name: 'should parse MultiTargetJoin sum', + targetVector: multiTargetVector().sum(['a', 'b']), + supportsTargets: true, + supportsWeightsForTargets: false, + out: { + targets: Targets.fromPartial({ + combination: CombinationMethod.COMBINATION_METHOD_TYPE_SUM, + targetVectors: ['a', 'b'], + }), + }, + }, + ]; + const test = (test: Test) => + it(test.name, () => { + const args = Serialize.targetVector(test); + expect(args).toEqual(test.out); + }); + tests.forEach(test); + }); + describe('.filtersGRPC', () => { it('should parse a text property', () => { const f = filter().byProperty('name').equal('test'); diff --git a/src/collections/vectors/multiTargetVector.ts b/src/collections/vectors/multiTargetVector.ts index edf8ccf5..f9d2abdf 100644 --- a/src/collections/vectors/multiTargetVector.ts +++ b/src/collections/vectors/multiTargetVector.ts @@ -1,3 +1,4 @@ +/** The allowed combination methods for multi-target vector joins */ export type MultiTargetVectorJoinCombination = | 'sum' | 'average' @@ -5,31 +6,38 @@ export type MultiTargetVectorJoinCombination = | 'relative-score' | 'manual-weights'; +/** Weights for each target vector in a multi-target vector join */ +export type MultiTargetVectorWeights = Record; + +/** A multi-target vector join used when specifying a vector-based query */ export type MultiTargetVectorJoin = { + /** The combination method to use for the target vectors */ combination: MultiTargetVectorJoinCombination; + /** The target vectors to combine */ targetVectors: string[]; - weights?: Record; + /** The weights to use for each target vector */ + weights?: MultiTargetVectorWeights; }; export default () => { return { - sum: (targetVectors: string[]) => { + sum: (targetVectors: string[]): MultiTargetVectorJoin => { return { combination: 'sum' as MultiTargetVectorJoinCombination, targetVectors }; }, - average: (targetVectors: string[]) => { + average: (targetVectors: string[]): MultiTargetVectorJoin => { return { combination: 'average' as MultiTargetVectorJoinCombination, targetVectors }; }, - minimum: (targetVectors: string[]) => { + minimum: (targetVectors: string[]): MultiTargetVectorJoin => { return { combination: 'minimum' as MultiTargetVectorJoinCombination, targetVectors }; }, - relativeScore: (weights: Record) => { + relativeScore: (weights: MultiTargetVectorWeights): MultiTargetVectorJoin => { return { combination: 'relative-score' as MultiTargetVectorJoinCombination, targetVectors: Object.keys(weights), weights, }; }, - manualWeights: (weights: Record) => { + manualWeights: (weights: MultiTargetVectorWeights): MultiTargetVectorJoin => { return { combination: 'manual-weights' as MultiTargetVectorJoinCombination, targetVectors: Object.keys(weights), @@ -40,9 +48,14 @@ export default () => { }; export interface MultiTargetVector { + /** Create a multi-target vector join that sums the vector scores over the target vectors */ sum: (targetVectors: string[]) => MultiTargetVectorJoin; + /** Create a multi-target vector join that averages the vector scores over the target vectors */ average: (targetVectors: string[]) => MultiTargetVectorJoin; + /** Create a multi-target vector join that takes the minimum vector score over the target vectors */ minimum: (targetVectors: string[]) => MultiTargetVectorJoin; - relativeScore: (weights: Record) => MultiTargetVectorJoin; - manualWeights: (weights: Record) => MultiTargetVectorJoin; + /** Create a multi-target vector join that uses relative weights for each target vector */ + relativeScore: (weights: MultiTargetVectorWeights) => MultiTargetVectorJoin; + /** Create a multi-target vector join that uses manual weights for each target vector */ + manualWeights: (weights: MultiTargetVectorWeights) => MultiTargetVectorJoin; } diff --git a/src/grpc/searcher.ts b/src/grpc/searcher.ts index 82300b9a..7aedd78e 100644 --- a/src/grpc/searcher.ts +++ b/src/grpc/searcher.ts @@ -4,7 +4,6 @@ import { Metadata } from 'nice-grpc'; import { Filters } from '../proto/v1/base.js'; import { BM25, - GenerativeSearch, GroupBy, Hybrid, MetadataRequest, @@ -26,6 +25,7 @@ import { import { WeaviateClient } from '../proto/v1/weaviate.js'; import { WeaviateQueryError } from '../errors.js'; +import { GenerativeSearch } from '../proto/v1/generative.js'; import Base from './base.js'; export type SearchFetchArgs = { diff --git a/src/proto/v1/generative.ts b/src/proto/v1/generative.ts new file mode 100644 index 00000000..3d61af30 --- /dev/null +++ b/src/proto/v1/generative.ts @@ -0,0 +1,4066 @@ +// Code generated by protoc-gen-ts_proto. DO NOT EDIT. +// versions: +// protoc-gen-ts_proto v1.176.0 +// protoc v3.19.1 +// source: v1/generative.proto + +/* eslint-disable */ +import Long from "long"; +import _m0 from "protobufjs/minimal.js"; +import { TextArray } from "./base.js"; + +export const protobufPackage = "weaviate.v1"; + +export interface GenerativeSearch { + /** @deprecated */ + singleResponsePrompt: string; + /** @deprecated */ + groupedResponseTask: string; + /** @deprecated */ + groupedProperties: string[]; + single: GenerativeSearch_Single | undefined; + grouped: GenerativeSearch_Grouped | undefined; +} + +export interface GenerativeSearch_Single { + prompt: string; + debug: boolean; + /** only allow one at the beginning, but multiple in the future */ + queries: GenerativeProvider[]; +} + +export interface GenerativeSearch_Grouped { + task: string; + properties?: TextArray | undefined; +} + +export interface GenerativeProvider { + returnMetadata: boolean; + anthropic?: GenerativeAnthropic | undefined; + anyscale?: GenerativeAnyscale | undefined; + aws?: GenerativeAWS | undefined; + cohere?: GenerativeCohere | undefined; + dummy?: GenerativeDummy | undefined; + mistral?: GenerativeMistral | undefined; + octoai?: GenerativeOctoAI | undefined; + ollama?: GenerativeOllama | undefined; + openai?: GenerativeOpenAI | undefined; + google?: GenerativeGoogle | undefined; +} + +export interface GenerativeAnthropic { + baseUrl?: string | undefined; + maxTokens?: number | undefined; + model?: string | undefined; + temperature?: number | undefined; + topK?: number | undefined; + topP?: number | undefined; + stopSequences?: TextArray | undefined; +} + +export interface GenerativeAnyscale { + baseUrl?: string | undefined; + model?: string | undefined; + temperature?: number | undefined; +} + +export interface GenerativeAWS { + model?: string | undefined; + temperature?: number | undefined; +} + +export interface GenerativeCohere { + baseUrl?: string | undefined; + frequencyPenalty?: number | undefined; + maxTokens?: number | undefined; + model?: string | undefined; + k?: number | undefined; + p?: number | undefined; + presencePenalty?: number | undefined; + stopSequences?: TextArray | undefined; + temperature?: number | undefined; +} + +export interface GenerativeDummy { +} + +export interface GenerativeMistral { + baseUrl?: string | undefined; + maxTokens?: number | undefined; + model?: string | undefined; + temperature?: number | undefined; + topP?: number | undefined; +} + +export interface GenerativeOctoAI { + baseUrl?: string | undefined; + maxTokens?: number | undefined; + model?: string | undefined; + n?: number | undefined; + temperature?: number | undefined; + topP?: number | undefined; +} + +export interface GenerativeOllama { + apiEndpoint?: string | undefined; + model?: string | undefined; + temperature?: number | undefined; +} + +export interface GenerativeOpenAI { + frequencyPenalty?: number | undefined; + logProbs?: boolean | undefined; + maxTokens?: number | undefined; + model: string; + n?: number | undefined; + presencePenalty?: number | undefined; + stop?: TextArray | undefined; + temperature?: number | undefined; + topP?: number | undefined; + topLogProbs?: number | undefined; +} + +export interface GenerativeGoogle { + frequencyPenalty?: number | undefined; + maxTokens?: number | undefined; + model?: string | undefined; + presencePenalty?: number | undefined; + temperature?: number | undefined; + topK?: number | undefined; + topP?: number | undefined; + stopSequences?: TextArray | undefined; +} + +export interface GenerativeAnthropicMetadata { + usage: GenerativeAnthropicMetadata_Usage | undefined; +} + +export interface GenerativeAnthropicMetadata_Usage { + inputTokens: number; + outputTokens: number; +} + +export interface GenerativeAnyscaleMetadata { +} + +export interface GenerativeAWSMetadata { +} + +export interface GenerativeCohereMetadata { + apiVersion?: GenerativeCohereMetadata_ApiVersion | undefined; + billedUnits?: GenerativeCohereMetadata_BilledUnits | undefined; + tokens?: GenerativeCohereMetadata_Tokens | undefined; + warnings?: TextArray | undefined; +} + +export interface GenerativeCohereMetadata_ApiVersion { + version?: string | undefined; + isDeprecated?: boolean | undefined; + isExperimental?: boolean | undefined; +} + +export interface GenerativeCohereMetadata_BilledUnits { + inputTokens?: number | undefined; + outputTokens?: number | undefined; + searchUnits?: number | undefined; + classifications?: number | undefined; +} + +export interface GenerativeCohereMetadata_Tokens { + inputTokens?: number | undefined; + outputTokens?: number | undefined; +} + +export interface GenerativeDummyMetadata { +} + +export interface GenerativeMistralMetadata { + usage?: GenerativeMistralMetadata_Usage | undefined; +} + +export interface GenerativeMistralMetadata_Usage { + promptTokens?: number | undefined; + completionTokens?: number | undefined; + totalTokens?: number | undefined; +} + +export interface GenerativeOctoAIMetadata { + usage?: GenerativeOctoAIMetadata_Usage | undefined; +} + +export interface GenerativeOctoAIMetadata_Usage { + promptTokens?: number | undefined; + completionTokens?: number | undefined; + totalTokens?: number | undefined; +} + +export interface GenerativeOllamaMetadata { +} + +export interface GenerativeOpenAIMetadata { + usage?: GenerativeOpenAIMetadata_Usage | undefined; +} + +export interface GenerativeOpenAIMetadata_Usage { + promptTokens?: number | undefined; + completionTokens?: number | undefined; + totalTokens?: number | undefined; +} + +export interface GenerativeGoogleMetadata { + metadata?: GenerativeGoogleMetadata_Metadata | undefined; + usageMetadata?: GenerativeGoogleMetadata_UsageMetadata | undefined; +} + +export interface GenerativeGoogleMetadata_TokenCount { + totalBillableCharacters?: number | undefined; + totalTokens?: number | undefined; +} + +export interface GenerativeGoogleMetadata_TokenMetadata { + inputTokenCount?: GenerativeGoogleMetadata_TokenCount | undefined; + outputTokenCount?: GenerativeGoogleMetadata_TokenCount | undefined; +} + +export interface GenerativeGoogleMetadata_Metadata { + tokenMetadata?: GenerativeGoogleMetadata_TokenMetadata | undefined; +} + +export interface GenerativeGoogleMetadata_UsageMetadata { + promptTokenCount?: number | undefined; + candidatesTokenCount?: number | undefined; + totalTokenCount?: number | undefined; +} + +export interface GenerativeMetadata { + anthropic?: GenerativeAnthropicMetadata | undefined; + anyscale?: GenerativeAnyscaleMetadata | undefined; + aws?: GenerativeAWSMetadata | undefined; + cohere?: GenerativeCohereMetadata | undefined; + dummy?: GenerativeDummyMetadata | undefined; + mistral?: GenerativeMistralMetadata | undefined; + octoai?: GenerativeOctoAIMetadata | undefined; + ollama?: GenerativeOllamaMetadata | undefined; + openai?: GenerativeOpenAIMetadata | undefined; + google?: GenerativeGoogleMetadata | undefined; +} + +export interface GenerativeReply { + result: string; + debug?: GenerativeDebug | undefined; + metadata?: GenerativeMetadata | undefined; +} + +export interface GenerativeResult { + values: GenerativeReply[]; +} + +export interface GenerativeDebug { + fullPrompt?: string | undefined; +} + +function createBaseGenerativeSearch(): GenerativeSearch { + return { + singleResponsePrompt: "", + groupedResponseTask: "", + groupedProperties: [], + single: undefined, + grouped: undefined, + }; +} + +export const GenerativeSearch = { + encode(message: GenerativeSearch, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.singleResponsePrompt !== "") { + writer.uint32(10).string(message.singleResponsePrompt); + } + if (message.groupedResponseTask !== "") { + writer.uint32(18).string(message.groupedResponseTask); + } + for (const v of message.groupedProperties) { + writer.uint32(26).string(v!); + } + if (message.single !== undefined) { + GenerativeSearch_Single.encode(message.single, writer.uint32(34).fork()).ldelim(); + } + if (message.grouped !== undefined) { + GenerativeSearch_Grouped.encode(message.grouped, writer.uint32(42).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeSearch { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeSearch(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.singleResponsePrompt = reader.string(); + continue; + case 2: + if (tag !== 18) { + break; + } + + message.groupedResponseTask = reader.string(); + continue; + case 3: + if (tag !== 26) { + break; + } + + message.groupedProperties.push(reader.string()); + continue; + case 4: + if (tag !== 34) { + break; + } + + message.single = GenerativeSearch_Single.decode(reader, reader.uint32()); + continue; + case 5: + if (tag !== 42) { + break; + } + + message.grouped = GenerativeSearch_Grouped.decode(reader, reader.uint32()); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeSearch { + return { + singleResponsePrompt: isSet(object.singleResponsePrompt) ? globalThis.String(object.singleResponsePrompt) : "", + groupedResponseTask: isSet(object.groupedResponseTask) ? globalThis.String(object.groupedResponseTask) : "", + groupedProperties: globalThis.Array.isArray(object?.groupedProperties) + ? object.groupedProperties.map((e: any) => globalThis.String(e)) + : [], + single: isSet(object.single) ? GenerativeSearch_Single.fromJSON(object.single) : undefined, + grouped: isSet(object.grouped) ? GenerativeSearch_Grouped.fromJSON(object.grouped) : undefined, + }; + }, + + toJSON(message: GenerativeSearch): unknown { + const obj: any = {}; + if (message.singleResponsePrompt !== "") { + obj.singleResponsePrompt = message.singleResponsePrompt; + } + if (message.groupedResponseTask !== "") { + obj.groupedResponseTask = message.groupedResponseTask; + } + if (message.groupedProperties?.length) { + obj.groupedProperties = message.groupedProperties; + } + if (message.single !== undefined) { + obj.single = GenerativeSearch_Single.toJSON(message.single); + } + if (message.grouped !== undefined) { + obj.grouped = GenerativeSearch_Grouped.toJSON(message.grouped); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeSearch { + return GenerativeSearch.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeSearch { + const message = createBaseGenerativeSearch(); + message.singleResponsePrompt = object.singleResponsePrompt ?? ""; + message.groupedResponseTask = object.groupedResponseTask ?? ""; + message.groupedProperties = object.groupedProperties?.map((e) => e) || []; + message.single = (object.single !== undefined && object.single !== null) + ? GenerativeSearch_Single.fromPartial(object.single) + : undefined; + message.grouped = (object.grouped !== undefined && object.grouped !== null) + ? GenerativeSearch_Grouped.fromPartial(object.grouped) + : undefined; + return message; + }, +}; + +function createBaseGenerativeSearch_Single(): GenerativeSearch_Single { + return { prompt: "", debug: false, queries: [] }; +} + +export const GenerativeSearch_Single = { + encode(message: GenerativeSearch_Single, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.prompt !== "") { + writer.uint32(10).string(message.prompt); + } + if (message.debug !== false) { + writer.uint32(16).bool(message.debug); + } + for (const v of message.queries) { + GenerativeProvider.encode(v!, writer.uint32(26).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeSearch_Single { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeSearch_Single(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.prompt = reader.string(); + continue; + case 2: + if (tag !== 16) { + break; + } + + message.debug = reader.bool(); + continue; + case 3: + if (tag !== 26) { + break; + } + + message.queries.push(GenerativeProvider.decode(reader, reader.uint32())); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeSearch_Single { + return { + prompt: isSet(object.prompt) ? globalThis.String(object.prompt) : "", + debug: isSet(object.debug) ? globalThis.Boolean(object.debug) : false, + queries: globalThis.Array.isArray(object?.queries) + ? object.queries.map((e: any) => GenerativeProvider.fromJSON(e)) + : [], + }; + }, + + toJSON(message: GenerativeSearch_Single): unknown { + const obj: any = {}; + if (message.prompt !== "") { + obj.prompt = message.prompt; + } + if (message.debug !== false) { + obj.debug = message.debug; + } + if (message.queries?.length) { + obj.queries = message.queries.map((e) => GenerativeProvider.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeSearch_Single { + return GenerativeSearch_Single.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeSearch_Single { + const message = createBaseGenerativeSearch_Single(); + message.prompt = object.prompt ?? ""; + message.debug = object.debug ?? false; + message.queries = object.queries?.map((e) => GenerativeProvider.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseGenerativeSearch_Grouped(): GenerativeSearch_Grouped { + return { task: "", properties: undefined }; +} + +export const GenerativeSearch_Grouped = { + encode(message: GenerativeSearch_Grouped, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.task !== "") { + writer.uint32(10).string(message.task); + } + if (message.properties !== undefined) { + TextArray.encode(message.properties, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeSearch_Grouped { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeSearch_Grouped(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.task = reader.string(); + continue; + case 2: + if (tag !== 18) { + break; + } + + message.properties = TextArray.decode(reader, reader.uint32()); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeSearch_Grouped { + return { + task: isSet(object.task) ? globalThis.String(object.task) : "", + properties: isSet(object.properties) ? TextArray.fromJSON(object.properties) : undefined, + }; + }, + + toJSON(message: GenerativeSearch_Grouped): unknown { + const obj: any = {}; + if (message.task !== "") { + obj.task = message.task; + } + if (message.properties !== undefined) { + obj.properties = TextArray.toJSON(message.properties); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeSearch_Grouped { + return GenerativeSearch_Grouped.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeSearch_Grouped { + const message = createBaseGenerativeSearch_Grouped(); + message.task = object.task ?? ""; + message.properties = (object.properties !== undefined && object.properties !== null) + ? TextArray.fromPartial(object.properties) + : undefined; + return message; + }, +}; + +function createBaseGenerativeProvider(): GenerativeProvider { + return { + returnMetadata: false, + anthropic: undefined, + anyscale: undefined, + aws: undefined, + cohere: undefined, + dummy: undefined, + mistral: undefined, + octoai: undefined, + ollama: undefined, + openai: undefined, + google: undefined, + }; +} + +export const GenerativeProvider = { + encode(message: GenerativeProvider, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.returnMetadata !== false) { + writer.uint32(8).bool(message.returnMetadata); + } + if (message.anthropic !== undefined) { + GenerativeAnthropic.encode(message.anthropic, writer.uint32(18).fork()).ldelim(); + } + if (message.anyscale !== undefined) { + GenerativeAnyscale.encode(message.anyscale, writer.uint32(26).fork()).ldelim(); + } + if (message.aws !== undefined) { + GenerativeAWS.encode(message.aws, writer.uint32(34).fork()).ldelim(); + } + if (message.cohere !== undefined) { + GenerativeCohere.encode(message.cohere, writer.uint32(42).fork()).ldelim(); + } + if (message.dummy !== undefined) { + GenerativeDummy.encode(message.dummy, writer.uint32(50).fork()).ldelim(); + } + if (message.mistral !== undefined) { + GenerativeMistral.encode(message.mistral, writer.uint32(58).fork()).ldelim(); + } + if (message.octoai !== undefined) { + GenerativeOctoAI.encode(message.octoai, writer.uint32(66).fork()).ldelim(); + } + if (message.ollama !== undefined) { + GenerativeOllama.encode(message.ollama, writer.uint32(74).fork()).ldelim(); + } + if (message.openai !== undefined) { + GenerativeOpenAI.encode(message.openai, writer.uint32(82).fork()).ldelim(); + } + if (message.google !== undefined) { + GenerativeGoogle.encode(message.google, writer.uint32(90).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeProvider { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeProvider(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 8) { + break; + } + + message.returnMetadata = reader.bool(); + continue; + case 2: + if (tag !== 18) { + break; + } + + message.anthropic = GenerativeAnthropic.decode(reader, reader.uint32()); + continue; + case 3: + if (tag !== 26) { + break; + } + + message.anyscale = GenerativeAnyscale.decode(reader, reader.uint32()); + continue; + case 4: + if (tag !== 34) { + break; + } + + message.aws = GenerativeAWS.decode(reader, reader.uint32()); + continue; + case 5: + if (tag !== 42) { + break; + } + + message.cohere = GenerativeCohere.decode(reader, reader.uint32()); + continue; + case 6: + if (tag !== 50) { + break; + } + + message.dummy = GenerativeDummy.decode(reader, reader.uint32()); + continue; + case 7: + if (tag !== 58) { + break; + } + + message.mistral = GenerativeMistral.decode(reader, reader.uint32()); + continue; + case 8: + if (tag !== 66) { + break; + } + + message.octoai = GenerativeOctoAI.decode(reader, reader.uint32()); + continue; + case 9: + if (tag !== 74) { + break; + } + + message.ollama = GenerativeOllama.decode(reader, reader.uint32()); + continue; + case 10: + if (tag !== 82) { + break; + } + + message.openai = GenerativeOpenAI.decode(reader, reader.uint32()); + continue; + case 11: + if (tag !== 90) { + break; + } + + message.google = GenerativeGoogle.decode(reader, reader.uint32()); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeProvider { + return { + returnMetadata: isSet(object.returnMetadata) ? globalThis.Boolean(object.returnMetadata) : false, + anthropic: isSet(object.anthropic) ? GenerativeAnthropic.fromJSON(object.anthropic) : undefined, + anyscale: isSet(object.anyscale) ? GenerativeAnyscale.fromJSON(object.anyscale) : undefined, + aws: isSet(object.aws) ? GenerativeAWS.fromJSON(object.aws) : undefined, + cohere: isSet(object.cohere) ? GenerativeCohere.fromJSON(object.cohere) : undefined, + dummy: isSet(object.dummy) ? GenerativeDummy.fromJSON(object.dummy) : undefined, + mistral: isSet(object.mistral) ? GenerativeMistral.fromJSON(object.mistral) : undefined, + octoai: isSet(object.octoai) ? GenerativeOctoAI.fromJSON(object.octoai) : undefined, + ollama: isSet(object.ollama) ? GenerativeOllama.fromJSON(object.ollama) : undefined, + openai: isSet(object.openai) ? GenerativeOpenAI.fromJSON(object.openai) : undefined, + google: isSet(object.google) ? GenerativeGoogle.fromJSON(object.google) : undefined, + }; + }, + + toJSON(message: GenerativeProvider): unknown { + const obj: any = {}; + if (message.returnMetadata !== false) { + obj.returnMetadata = message.returnMetadata; + } + if (message.anthropic !== undefined) { + obj.anthropic = GenerativeAnthropic.toJSON(message.anthropic); + } + if (message.anyscale !== undefined) { + obj.anyscale = GenerativeAnyscale.toJSON(message.anyscale); + } + if (message.aws !== undefined) { + obj.aws = GenerativeAWS.toJSON(message.aws); + } + if (message.cohere !== undefined) { + obj.cohere = GenerativeCohere.toJSON(message.cohere); + } + if (message.dummy !== undefined) { + obj.dummy = GenerativeDummy.toJSON(message.dummy); + } + if (message.mistral !== undefined) { + obj.mistral = GenerativeMistral.toJSON(message.mistral); + } + if (message.octoai !== undefined) { + obj.octoai = GenerativeOctoAI.toJSON(message.octoai); + } + if (message.ollama !== undefined) { + obj.ollama = GenerativeOllama.toJSON(message.ollama); + } + if (message.openai !== undefined) { + obj.openai = GenerativeOpenAI.toJSON(message.openai); + } + if (message.google !== undefined) { + obj.google = GenerativeGoogle.toJSON(message.google); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeProvider { + return GenerativeProvider.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeProvider { + const message = createBaseGenerativeProvider(); + message.returnMetadata = object.returnMetadata ?? false; + message.anthropic = (object.anthropic !== undefined && object.anthropic !== null) + ? GenerativeAnthropic.fromPartial(object.anthropic) + : undefined; + message.anyscale = (object.anyscale !== undefined && object.anyscale !== null) + ? GenerativeAnyscale.fromPartial(object.anyscale) + : undefined; + message.aws = (object.aws !== undefined && object.aws !== null) ? GenerativeAWS.fromPartial(object.aws) : undefined; + message.cohere = (object.cohere !== undefined && object.cohere !== null) + ? GenerativeCohere.fromPartial(object.cohere) + : undefined; + message.dummy = (object.dummy !== undefined && object.dummy !== null) + ? GenerativeDummy.fromPartial(object.dummy) + : undefined; + message.mistral = (object.mistral !== undefined && object.mistral !== null) + ? GenerativeMistral.fromPartial(object.mistral) + : undefined; + message.octoai = (object.octoai !== undefined && object.octoai !== null) + ? GenerativeOctoAI.fromPartial(object.octoai) + : undefined; + message.ollama = (object.ollama !== undefined && object.ollama !== null) + ? GenerativeOllama.fromPartial(object.ollama) + : undefined; + message.openai = (object.openai !== undefined && object.openai !== null) + ? GenerativeOpenAI.fromPartial(object.openai) + : undefined; + message.google = (object.google !== undefined && object.google !== null) + ? GenerativeGoogle.fromPartial(object.google) + : undefined; + return message; + }, +}; + +function createBaseGenerativeAnthropic(): GenerativeAnthropic { + return { + baseUrl: undefined, + maxTokens: undefined, + model: undefined, + temperature: undefined, + topK: undefined, + topP: undefined, + stopSequences: undefined, + }; +} + +export const GenerativeAnthropic = { + encode(message: GenerativeAnthropic, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.baseUrl !== undefined) { + writer.uint32(10).string(message.baseUrl); + } + if (message.maxTokens !== undefined) { + writer.uint32(16).int64(message.maxTokens); + } + if (message.model !== undefined) { + writer.uint32(26).string(message.model); + } + if (message.temperature !== undefined) { + writer.uint32(33).double(message.temperature); + } + if (message.topK !== undefined) { + writer.uint32(40).int64(message.topK); + } + if (message.topP !== undefined) { + writer.uint32(49).double(message.topP); + } + if (message.stopSequences !== undefined) { + TextArray.encode(message.stopSequences, writer.uint32(58).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeAnthropic { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeAnthropic(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.baseUrl = reader.string(); + continue; + case 2: + if (tag !== 16) { + break; + } + + message.maxTokens = longToNumber(reader.int64() as Long); + continue; + case 3: + if (tag !== 26) { + break; + } + + message.model = reader.string(); + continue; + case 4: + if (tag !== 33) { + break; + } + + message.temperature = reader.double(); + continue; + case 5: + if (tag !== 40) { + break; + } + + message.topK = longToNumber(reader.int64() as Long); + continue; + case 6: + if (tag !== 49) { + break; + } + + message.topP = reader.double(); + continue; + case 7: + if (tag !== 58) { + break; + } + + message.stopSequences = TextArray.decode(reader, reader.uint32()); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeAnthropic { + return { + baseUrl: isSet(object.baseUrl) ? globalThis.String(object.baseUrl) : undefined, + maxTokens: isSet(object.maxTokens) ? globalThis.Number(object.maxTokens) : undefined, + model: isSet(object.model) ? globalThis.String(object.model) : undefined, + temperature: isSet(object.temperature) ? globalThis.Number(object.temperature) : undefined, + topK: isSet(object.topK) ? globalThis.Number(object.topK) : undefined, + topP: isSet(object.topP) ? globalThis.Number(object.topP) : undefined, + stopSequences: isSet(object.stopSequences) ? TextArray.fromJSON(object.stopSequences) : undefined, + }; + }, + + toJSON(message: GenerativeAnthropic): unknown { + const obj: any = {}; + if (message.baseUrl !== undefined) { + obj.baseUrl = message.baseUrl; + } + if (message.maxTokens !== undefined) { + obj.maxTokens = Math.round(message.maxTokens); + } + if (message.model !== undefined) { + obj.model = message.model; + } + if (message.temperature !== undefined) { + obj.temperature = message.temperature; + } + if (message.topK !== undefined) { + obj.topK = Math.round(message.topK); + } + if (message.topP !== undefined) { + obj.topP = message.topP; + } + if (message.stopSequences !== undefined) { + obj.stopSequences = TextArray.toJSON(message.stopSequences); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeAnthropic { + return GenerativeAnthropic.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeAnthropic { + const message = createBaseGenerativeAnthropic(); + message.baseUrl = object.baseUrl ?? undefined; + message.maxTokens = object.maxTokens ?? undefined; + message.model = object.model ?? undefined; + message.temperature = object.temperature ?? undefined; + message.topK = object.topK ?? undefined; + message.topP = object.topP ?? undefined; + message.stopSequences = (object.stopSequences !== undefined && object.stopSequences !== null) + ? TextArray.fromPartial(object.stopSequences) + : undefined; + return message; + }, +}; + +function createBaseGenerativeAnyscale(): GenerativeAnyscale { + return { baseUrl: undefined, model: undefined, temperature: undefined }; +} + +export const GenerativeAnyscale = { + encode(message: GenerativeAnyscale, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.baseUrl !== undefined) { + writer.uint32(10).string(message.baseUrl); + } + if (message.model !== undefined) { + writer.uint32(18).string(message.model); + } + if (message.temperature !== undefined) { + writer.uint32(25).double(message.temperature); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeAnyscale { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeAnyscale(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.baseUrl = reader.string(); + continue; + case 2: + if (tag !== 18) { + break; + } + + message.model = reader.string(); + continue; + case 3: + if (tag !== 25) { + break; + } + + message.temperature = reader.double(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeAnyscale { + return { + baseUrl: isSet(object.baseUrl) ? globalThis.String(object.baseUrl) : undefined, + model: isSet(object.model) ? globalThis.String(object.model) : undefined, + temperature: isSet(object.temperature) ? globalThis.Number(object.temperature) : undefined, + }; + }, + + toJSON(message: GenerativeAnyscale): unknown { + const obj: any = {}; + if (message.baseUrl !== undefined) { + obj.baseUrl = message.baseUrl; + } + if (message.model !== undefined) { + obj.model = message.model; + } + if (message.temperature !== undefined) { + obj.temperature = message.temperature; + } + return obj; + }, + + create(base?: DeepPartial): GenerativeAnyscale { + return GenerativeAnyscale.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeAnyscale { + const message = createBaseGenerativeAnyscale(); + message.baseUrl = object.baseUrl ?? undefined; + message.model = object.model ?? undefined; + message.temperature = object.temperature ?? undefined; + return message; + }, +}; + +function createBaseGenerativeAWS(): GenerativeAWS { + return { model: undefined, temperature: undefined }; +} + +export const GenerativeAWS = { + encode(message: GenerativeAWS, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.model !== undefined) { + writer.uint32(26).string(message.model); + } + if (message.temperature !== undefined) { + writer.uint32(65).double(message.temperature); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeAWS { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeAWS(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 3: + if (tag !== 26) { + break; + } + + message.model = reader.string(); + continue; + case 8: + if (tag !== 65) { + break; + } + + message.temperature = reader.double(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeAWS { + return { + model: isSet(object.model) ? globalThis.String(object.model) : undefined, + temperature: isSet(object.temperature) ? globalThis.Number(object.temperature) : undefined, + }; + }, + + toJSON(message: GenerativeAWS): unknown { + const obj: any = {}; + if (message.model !== undefined) { + obj.model = message.model; + } + if (message.temperature !== undefined) { + obj.temperature = message.temperature; + } + return obj; + }, + + create(base?: DeepPartial): GenerativeAWS { + return GenerativeAWS.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeAWS { + const message = createBaseGenerativeAWS(); + message.model = object.model ?? undefined; + message.temperature = object.temperature ?? undefined; + return message; + }, +}; + +function createBaseGenerativeCohere(): GenerativeCohere { + return { + baseUrl: undefined, + frequencyPenalty: undefined, + maxTokens: undefined, + model: undefined, + k: undefined, + p: undefined, + presencePenalty: undefined, + stopSequences: undefined, + temperature: undefined, + }; +} + +export const GenerativeCohere = { + encode(message: GenerativeCohere, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.baseUrl !== undefined) { + writer.uint32(10).string(message.baseUrl); + } + if (message.frequencyPenalty !== undefined) { + writer.uint32(17).double(message.frequencyPenalty); + } + if (message.maxTokens !== undefined) { + writer.uint32(24).int64(message.maxTokens); + } + if (message.model !== undefined) { + writer.uint32(34).string(message.model); + } + if (message.k !== undefined) { + writer.uint32(40).int64(message.k); + } + if (message.p !== undefined) { + writer.uint32(49).double(message.p); + } + if (message.presencePenalty !== undefined) { + writer.uint32(57).double(message.presencePenalty); + } + if (message.stopSequences !== undefined) { + TextArray.encode(message.stopSequences, writer.uint32(66).fork()).ldelim(); + } + if (message.temperature !== undefined) { + writer.uint32(73).double(message.temperature); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeCohere { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeCohere(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.baseUrl = reader.string(); + continue; + case 2: + if (tag !== 17) { + break; + } + + message.frequencyPenalty = reader.double(); + continue; + case 3: + if (tag !== 24) { + break; + } + + message.maxTokens = longToNumber(reader.int64() as Long); + continue; + case 4: + if (tag !== 34) { + break; + } + + message.model = reader.string(); + continue; + case 5: + if (tag !== 40) { + break; + } + + message.k = longToNumber(reader.int64() as Long); + continue; + case 6: + if (tag !== 49) { + break; + } + + message.p = reader.double(); + continue; + case 7: + if (tag !== 57) { + break; + } + + message.presencePenalty = reader.double(); + continue; + case 8: + if (tag !== 66) { + break; + } + + message.stopSequences = TextArray.decode(reader, reader.uint32()); + continue; + case 9: + if (tag !== 73) { + break; + } + + message.temperature = reader.double(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeCohere { + return { + baseUrl: isSet(object.baseUrl) ? globalThis.String(object.baseUrl) : undefined, + frequencyPenalty: isSet(object.frequencyPenalty) ? globalThis.Number(object.frequencyPenalty) : undefined, + maxTokens: isSet(object.maxTokens) ? globalThis.Number(object.maxTokens) : undefined, + model: isSet(object.model) ? globalThis.String(object.model) : undefined, + k: isSet(object.k) ? globalThis.Number(object.k) : undefined, + p: isSet(object.p) ? globalThis.Number(object.p) : undefined, + presencePenalty: isSet(object.presencePenalty) ? globalThis.Number(object.presencePenalty) : undefined, + stopSequences: isSet(object.stopSequences) ? TextArray.fromJSON(object.stopSequences) : undefined, + temperature: isSet(object.temperature) ? globalThis.Number(object.temperature) : undefined, + }; + }, + + toJSON(message: GenerativeCohere): unknown { + const obj: any = {}; + if (message.baseUrl !== undefined) { + obj.baseUrl = message.baseUrl; + } + if (message.frequencyPenalty !== undefined) { + obj.frequencyPenalty = message.frequencyPenalty; + } + if (message.maxTokens !== undefined) { + obj.maxTokens = Math.round(message.maxTokens); + } + if (message.model !== undefined) { + obj.model = message.model; + } + if (message.k !== undefined) { + obj.k = Math.round(message.k); + } + if (message.p !== undefined) { + obj.p = message.p; + } + if (message.presencePenalty !== undefined) { + obj.presencePenalty = message.presencePenalty; + } + if (message.stopSequences !== undefined) { + obj.stopSequences = TextArray.toJSON(message.stopSequences); + } + if (message.temperature !== undefined) { + obj.temperature = message.temperature; + } + return obj; + }, + + create(base?: DeepPartial): GenerativeCohere { + return GenerativeCohere.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeCohere { + const message = createBaseGenerativeCohere(); + message.baseUrl = object.baseUrl ?? undefined; + message.frequencyPenalty = object.frequencyPenalty ?? undefined; + message.maxTokens = object.maxTokens ?? undefined; + message.model = object.model ?? undefined; + message.k = object.k ?? undefined; + message.p = object.p ?? undefined; + message.presencePenalty = object.presencePenalty ?? undefined; + message.stopSequences = (object.stopSequences !== undefined && object.stopSequences !== null) + ? TextArray.fromPartial(object.stopSequences) + : undefined; + message.temperature = object.temperature ?? undefined; + return message; + }, +}; + +function createBaseGenerativeDummy(): GenerativeDummy { + return {}; +} + +export const GenerativeDummy = { + encode(_: GenerativeDummy, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeDummy { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeDummy(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(_: any): GenerativeDummy { + return {}; + }, + + toJSON(_: GenerativeDummy): unknown { + const obj: any = {}; + return obj; + }, + + create(base?: DeepPartial): GenerativeDummy { + return GenerativeDummy.fromPartial(base ?? {}); + }, + fromPartial(_: DeepPartial): GenerativeDummy { + const message = createBaseGenerativeDummy(); + return message; + }, +}; + +function createBaseGenerativeMistral(): GenerativeMistral { + return { baseUrl: undefined, maxTokens: undefined, model: undefined, temperature: undefined, topP: undefined }; +} + +export const GenerativeMistral = { + encode(message: GenerativeMistral, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.baseUrl !== undefined) { + writer.uint32(10).string(message.baseUrl); + } + if (message.maxTokens !== undefined) { + writer.uint32(16).int64(message.maxTokens); + } + if (message.model !== undefined) { + writer.uint32(26).string(message.model); + } + if (message.temperature !== undefined) { + writer.uint32(33).double(message.temperature); + } + if (message.topP !== undefined) { + writer.uint32(41).double(message.topP); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeMistral { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeMistral(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.baseUrl = reader.string(); + continue; + case 2: + if (tag !== 16) { + break; + } + + message.maxTokens = longToNumber(reader.int64() as Long); + continue; + case 3: + if (tag !== 26) { + break; + } + + message.model = reader.string(); + continue; + case 4: + if (tag !== 33) { + break; + } + + message.temperature = reader.double(); + continue; + case 5: + if (tag !== 41) { + break; + } + + message.topP = reader.double(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeMistral { + return { + baseUrl: isSet(object.baseUrl) ? globalThis.String(object.baseUrl) : undefined, + maxTokens: isSet(object.maxTokens) ? globalThis.Number(object.maxTokens) : undefined, + model: isSet(object.model) ? globalThis.String(object.model) : undefined, + temperature: isSet(object.temperature) ? globalThis.Number(object.temperature) : undefined, + topP: isSet(object.topP) ? globalThis.Number(object.topP) : undefined, + }; + }, + + toJSON(message: GenerativeMistral): unknown { + const obj: any = {}; + if (message.baseUrl !== undefined) { + obj.baseUrl = message.baseUrl; + } + if (message.maxTokens !== undefined) { + obj.maxTokens = Math.round(message.maxTokens); + } + if (message.model !== undefined) { + obj.model = message.model; + } + if (message.temperature !== undefined) { + obj.temperature = message.temperature; + } + if (message.topP !== undefined) { + obj.topP = message.topP; + } + return obj; + }, + + create(base?: DeepPartial): GenerativeMistral { + return GenerativeMistral.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeMistral { + const message = createBaseGenerativeMistral(); + message.baseUrl = object.baseUrl ?? undefined; + message.maxTokens = object.maxTokens ?? undefined; + message.model = object.model ?? undefined; + message.temperature = object.temperature ?? undefined; + message.topP = object.topP ?? undefined; + return message; + }, +}; + +function createBaseGenerativeOctoAI(): GenerativeOctoAI { + return { + baseUrl: undefined, + maxTokens: undefined, + model: undefined, + n: undefined, + temperature: undefined, + topP: undefined, + }; +} + +export const GenerativeOctoAI = { + encode(message: GenerativeOctoAI, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.baseUrl !== undefined) { + writer.uint32(10).string(message.baseUrl); + } + if (message.maxTokens !== undefined) { + writer.uint32(16).int64(message.maxTokens); + } + if (message.model !== undefined) { + writer.uint32(26).string(message.model); + } + if (message.n !== undefined) { + writer.uint32(32).int64(message.n); + } + if (message.temperature !== undefined) { + writer.uint32(41).double(message.temperature); + } + if (message.topP !== undefined) { + writer.uint32(49).double(message.topP); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeOctoAI { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeOctoAI(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.baseUrl = reader.string(); + continue; + case 2: + if (tag !== 16) { + break; + } + + message.maxTokens = longToNumber(reader.int64() as Long); + continue; + case 3: + if (tag !== 26) { + break; + } + + message.model = reader.string(); + continue; + case 4: + if (tag !== 32) { + break; + } + + message.n = longToNumber(reader.int64() as Long); + continue; + case 5: + if (tag !== 41) { + break; + } + + message.temperature = reader.double(); + continue; + case 6: + if (tag !== 49) { + break; + } + + message.topP = reader.double(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeOctoAI { + return { + baseUrl: isSet(object.baseUrl) ? globalThis.String(object.baseUrl) : undefined, + maxTokens: isSet(object.maxTokens) ? globalThis.Number(object.maxTokens) : undefined, + model: isSet(object.model) ? globalThis.String(object.model) : undefined, + n: isSet(object.n) ? globalThis.Number(object.n) : undefined, + temperature: isSet(object.temperature) ? globalThis.Number(object.temperature) : undefined, + topP: isSet(object.topP) ? globalThis.Number(object.topP) : undefined, + }; + }, + + toJSON(message: GenerativeOctoAI): unknown { + const obj: any = {}; + if (message.baseUrl !== undefined) { + obj.baseUrl = message.baseUrl; + } + if (message.maxTokens !== undefined) { + obj.maxTokens = Math.round(message.maxTokens); + } + if (message.model !== undefined) { + obj.model = message.model; + } + if (message.n !== undefined) { + obj.n = Math.round(message.n); + } + if (message.temperature !== undefined) { + obj.temperature = message.temperature; + } + if (message.topP !== undefined) { + obj.topP = message.topP; + } + return obj; + }, + + create(base?: DeepPartial): GenerativeOctoAI { + return GenerativeOctoAI.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeOctoAI { + const message = createBaseGenerativeOctoAI(); + message.baseUrl = object.baseUrl ?? undefined; + message.maxTokens = object.maxTokens ?? undefined; + message.model = object.model ?? undefined; + message.n = object.n ?? undefined; + message.temperature = object.temperature ?? undefined; + message.topP = object.topP ?? undefined; + return message; + }, +}; + +function createBaseGenerativeOllama(): GenerativeOllama { + return { apiEndpoint: undefined, model: undefined, temperature: undefined }; +} + +export const GenerativeOllama = { + encode(message: GenerativeOllama, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.apiEndpoint !== undefined) { + writer.uint32(10).string(message.apiEndpoint); + } + if (message.model !== undefined) { + writer.uint32(18).string(message.model); + } + if (message.temperature !== undefined) { + writer.uint32(25).double(message.temperature); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeOllama { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeOllama(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.apiEndpoint = reader.string(); + continue; + case 2: + if (tag !== 18) { + break; + } + + message.model = reader.string(); + continue; + case 3: + if (tag !== 25) { + break; + } + + message.temperature = reader.double(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeOllama { + return { + apiEndpoint: isSet(object.apiEndpoint) ? globalThis.String(object.apiEndpoint) : undefined, + model: isSet(object.model) ? globalThis.String(object.model) : undefined, + temperature: isSet(object.temperature) ? globalThis.Number(object.temperature) : undefined, + }; + }, + + toJSON(message: GenerativeOllama): unknown { + const obj: any = {}; + if (message.apiEndpoint !== undefined) { + obj.apiEndpoint = message.apiEndpoint; + } + if (message.model !== undefined) { + obj.model = message.model; + } + if (message.temperature !== undefined) { + obj.temperature = message.temperature; + } + return obj; + }, + + create(base?: DeepPartial): GenerativeOllama { + return GenerativeOllama.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeOllama { + const message = createBaseGenerativeOllama(); + message.apiEndpoint = object.apiEndpoint ?? undefined; + message.model = object.model ?? undefined; + message.temperature = object.temperature ?? undefined; + return message; + }, +}; + +function createBaseGenerativeOpenAI(): GenerativeOpenAI { + return { + frequencyPenalty: undefined, + logProbs: undefined, + maxTokens: undefined, + model: "", + n: undefined, + presencePenalty: undefined, + stop: undefined, + temperature: undefined, + topP: undefined, + topLogProbs: undefined, + }; +} + +export const GenerativeOpenAI = { + encode(message: GenerativeOpenAI, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.frequencyPenalty !== undefined) { + writer.uint32(9).double(message.frequencyPenalty); + } + if (message.logProbs !== undefined) { + writer.uint32(16).bool(message.logProbs); + } + if (message.maxTokens !== undefined) { + writer.uint32(24).int64(message.maxTokens); + } + if (message.model !== "") { + writer.uint32(34).string(message.model); + } + if (message.n !== undefined) { + writer.uint32(40).int64(message.n); + } + if (message.presencePenalty !== undefined) { + writer.uint32(49).double(message.presencePenalty); + } + if (message.stop !== undefined) { + TextArray.encode(message.stop, writer.uint32(58).fork()).ldelim(); + } + if (message.temperature !== undefined) { + writer.uint32(65).double(message.temperature); + } + if (message.topP !== undefined) { + writer.uint32(73).double(message.topP); + } + if (message.topLogProbs !== undefined) { + writer.uint32(80).int64(message.topLogProbs); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeOpenAI { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeOpenAI(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 9) { + break; + } + + message.frequencyPenalty = reader.double(); + continue; + case 2: + if (tag !== 16) { + break; + } + + message.logProbs = reader.bool(); + continue; + case 3: + if (tag !== 24) { + break; + } + + message.maxTokens = longToNumber(reader.int64() as Long); + continue; + case 4: + if (tag !== 34) { + break; + } + + message.model = reader.string(); + continue; + case 5: + if (tag !== 40) { + break; + } + + message.n = longToNumber(reader.int64() as Long); + continue; + case 6: + if (tag !== 49) { + break; + } + + message.presencePenalty = reader.double(); + continue; + case 7: + if (tag !== 58) { + break; + } + + message.stop = TextArray.decode(reader, reader.uint32()); + continue; + case 8: + if (tag !== 65) { + break; + } + + message.temperature = reader.double(); + continue; + case 9: + if (tag !== 73) { + break; + } + + message.topP = reader.double(); + continue; + case 10: + if (tag !== 80) { + break; + } + + message.topLogProbs = longToNumber(reader.int64() as Long); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeOpenAI { + return { + frequencyPenalty: isSet(object.frequencyPenalty) ? globalThis.Number(object.frequencyPenalty) : undefined, + logProbs: isSet(object.logProbs) ? globalThis.Boolean(object.logProbs) : undefined, + maxTokens: isSet(object.maxTokens) ? globalThis.Number(object.maxTokens) : undefined, + model: isSet(object.model) ? globalThis.String(object.model) : "", + n: isSet(object.n) ? globalThis.Number(object.n) : undefined, + presencePenalty: isSet(object.presencePenalty) ? globalThis.Number(object.presencePenalty) : undefined, + stop: isSet(object.stop) ? TextArray.fromJSON(object.stop) : undefined, + temperature: isSet(object.temperature) ? globalThis.Number(object.temperature) : undefined, + topP: isSet(object.topP) ? globalThis.Number(object.topP) : undefined, + topLogProbs: isSet(object.topLogProbs) ? globalThis.Number(object.topLogProbs) : undefined, + }; + }, + + toJSON(message: GenerativeOpenAI): unknown { + const obj: any = {}; + if (message.frequencyPenalty !== undefined) { + obj.frequencyPenalty = message.frequencyPenalty; + } + if (message.logProbs !== undefined) { + obj.logProbs = message.logProbs; + } + if (message.maxTokens !== undefined) { + obj.maxTokens = Math.round(message.maxTokens); + } + if (message.model !== "") { + obj.model = message.model; + } + if (message.n !== undefined) { + obj.n = Math.round(message.n); + } + if (message.presencePenalty !== undefined) { + obj.presencePenalty = message.presencePenalty; + } + if (message.stop !== undefined) { + obj.stop = TextArray.toJSON(message.stop); + } + if (message.temperature !== undefined) { + obj.temperature = message.temperature; + } + if (message.topP !== undefined) { + obj.topP = message.topP; + } + if (message.topLogProbs !== undefined) { + obj.topLogProbs = Math.round(message.topLogProbs); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeOpenAI { + return GenerativeOpenAI.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeOpenAI { + const message = createBaseGenerativeOpenAI(); + message.frequencyPenalty = object.frequencyPenalty ?? undefined; + message.logProbs = object.logProbs ?? undefined; + message.maxTokens = object.maxTokens ?? undefined; + message.model = object.model ?? ""; + message.n = object.n ?? undefined; + message.presencePenalty = object.presencePenalty ?? undefined; + message.stop = (object.stop !== undefined && object.stop !== null) ? TextArray.fromPartial(object.stop) : undefined; + message.temperature = object.temperature ?? undefined; + message.topP = object.topP ?? undefined; + message.topLogProbs = object.topLogProbs ?? undefined; + return message; + }, +}; + +function createBaseGenerativeGoogle(): GenerativeGoogle { + return { + frequencyPenalty: undefined, + maxTokens: undefined, + model: undefined, + presencePenalty: undefined, + temperature: undefined, + topK: undefined, + topP: undefined, + stopSequences: undefined, + }; +} + +export const GenerativeGoogle = { + encode(message: GenerativeGoogle, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.frequencyPenalty !== undefined) { + writer.uint32(9).double(message.frequencyPenalty); + } + if (message.maxTokens !== undefined) { + writer.uint32(16).int64(message.maxTokens); + } + if (message.model !== undefined) { + writer.uint32(26).string(message.model); + } + if (message.presencePenalty !== undefined) { + writer.uint32(33).double(message.presencePenalty); + } + if (message.temperature !== undefined) { + writer.uint32(41).double(message.temperature); + } + if (message.topK !== undefined) { + writer.uint32(48).int64(message.topK); + } + if (message.topP !== undefined) { + writer.uint32(57).double(message.topP); + } + if (message.stopSequences !== undefined) { + TextArray.encode(message.stopSequences, writer.uint32(66).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeGoogle { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeGoogle(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 9) { + break; + } + + message.frequencyPenalty = reader.double(); + continue; + case 2: + if (tag !== 16) { + break; + } + + message.maxTokens = longToNumber(reader.int64() as Long); + continue; + case 3: + if (tag !== 26) { + break; + } + + message.model = reader.string(); + continue; + case 4: + if (tag !== 33) { + break; + } + + message.presencePenalty = reader.double(); + continue; + case 5: + if (tag !== 41) { + break; + } + + message.temperature = reader.double(); + continue; + case 6: + if (tag !== 48) { + break; + } + + message.topK = longToNumber(reader.int64() as Long); + continue; + case 7: + if (tag !== 57) { + break; + } + + message.topP = reader.double(); + continue; + case 8: + if (tag !== 66) { + break; + } + + message.stopSequences = TextArray.decode(reader, reader.uint32()); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeGoogle { + return { + frequencyPenalty: isSet(object.frequencyPenalty) ? globalThis.Number(object.frequencyPenalty) : undefined, + maxTokens: isSet(object.maxTokens) ? globalThis.Number(object.maxTokens) : undefined, + model: isSet(object.model) ? globalThis.String(object.model) : undefined, + presencePenalty: isSet(object.presencePenalty) ? globalThis.Number(object.presencePenalty) : undefined, + temperature: isSet(object.temperature) ? globalThis.Number(object.temperature) : undefined, + topK: isSet(object.topK) ? globalThis.Number(object.topK) : undefined, + topP: isSet(object.topP) ? globalThis.Number(object.topP) : undefined, + stopSequences: isSet(object.stopSequences) ? TextArray.fromJSON(object.stopSequences) : undefined, + }; + }, + + toJSON(message: GenerativeGoogle): unknown { + const obj: any = {}; + if (message.frequencyPenalty !== undefined) { + obj.frequencyPenalty = message.frequencyPenalty; + } + if (message.maxTokens !== undefined) { + obj.maxTokens = Math.round(message.maxTokens); + } + if (message.model !== undefined) { + obj.model = message.model; + } + if (message.presencePenalty !== undefined) { + obj.presencePenalty = message.presencePenalty; + } + if (message.temperature !== undefined) { + obj.temperature = message.temperature; + } + if (message.topK !== undefined) { + obj.topK = Math.round(message.topK); + } + if (message.topP !== undefined) { + obj.topP = message.topP; + } + if (message.stopSequences !== undefined) { + obj.stopSequences = TextArray.toJSON(message.stopSequences); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeGoogle { + return GenerativeGoogle.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeGoogle { + const message = createBaseGenerativeGoogle(); + message.frequencyPenalty = object.frequencyPenalty ?? undefined; + message.maxTokens = object.maxTokens ?? undefined; + message.model = object.model ?? undefined; + message.presencePenalty = object.presencePenalty ?? undefined; + message.temperature = object.temperature ?? undefined; + message.topK = object.topK ?? undefined; + message.topP = object.topP ?? undefined; + message.stopSequences = (object.stopSequences !== undefined && object.stopSequences !== null) + ? TextArray.fromPartial(object.stopSequences) + : undefined; + return message; + }, +}; + +function createBaseGenerativeAnthropicMetadata(): GenerativeAnthropicMetadata { + return { usage: undefined }; +} + +export const GenerativeAnthropicMetadata = { + encode(message: GenerativeAnthropicMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.usage !== undefined) { + GenerativeAnthropicMetadata_Usage.encode(message.usage, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeAnthropicMetadata { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeAnthropicMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.usage = GenerativeAnthropicMetadata_Usage.decode(reader, reader.uint32()); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeAnthropicMetadata { + return { usage: isSet(object.usage) ? GenerativeAnthropicMetadata_Usage.fromJSON(object.usage) : undefined }; + }, + + toJSON(message: GenerativeAnthropicMetadata): unknown { + const obj: any = {}; + if (message.usage !== undefined) { + obj.usage = GenerativeAnthropicMetadata_Usage.toJSON(message.usage); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeAnthropicMetadata { + return GenerativeAnthropicMetadata.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeAnthropicMetadata { + const message = createBaseGenerativeAnthropicMetadata(); + message.usage = (object.usage !== undefined && object.usage !== null) + ? GenerativeAnthropicMetadata_Usage.fromPartial(object.usage) + : undefined; + return message; + }, +}; + +function createBaseGenerativeAnthropicMetadata_Usage(): GenerativeAnthropicMetadata_Usage { + return { inputTokens: 0, outputTokens: 0 }; +} + +export const GenerativeAnthropicMetadata_Usage = { + encode(message: GenerativeAnthropicMetadata_Usage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.inputTokens !== 0) { + writer.uint32(8).int64(message.inputTokens); + } + if (message.outputTokens !== 0) { + writer.uint32(16).int64(message.outputTokens); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeAnthropicMetadata_Usage { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeAnthropicMetadata_Usage(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 8) { + break; + } + + message.inputTokens = longToNumber(reader.int64() as Long); + continue; + case 2: + if (tag !== 16) { + break; + } + + message.outputTokens = longToNumber(reader.int64() as Long); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeAnthropicMetadata_Usage { + return { + inputTokens: isSet(object.inputTokens) ? globalThis.Number(object.inputTokens) : 0, + outputTokens: isSet(object.outputTokens) ? globalThis.Number(object.outputTokens) : 0, + }; + }, + + toJSON(message: GenerativeAnthropicMetadata_Usage): unknown { + const obj: any = {}; + if (message.inputTokens !== 0) { + obj.inputTokens = Math.round(message.inputTokens); + } + if (message.outputTokens !== 0) { + obj.outputTokens = Math.round(message.outputTokens); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeAnthropicMetadata_Usage { + return GenerativeAnthropicMetadata_Usage.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeAnthropicMetadata_Usage { + const message = createBaseGenerativeAnthropicMetadata_Usage(); + message.inputTokens = object.inputTokens ?? 0; + message.outputTokens = object.outputTokens ?? 0; + return message; + }, +}; + +function createBaseGenerativeAnyscaleMetadata(): GenerativeAnyscaleMetadata { + return {}; +} + +export const GenerativeAnyscaleMetadata = { + encode(_: GenerativeAnyscaleMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeAnyscaleMetadata { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeAnyscaleMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(_: any): GenerativeAnyscaleMetadata { + return {}; + }, + + toJSON(_: GenerativeAnyscaleMetadata): unknown { + const obj: any = {}; + return obj; + }, + + create(base?: DeepPartial): GenerativeAnyscaleMetadata { + return GenerativeAnyscaleMetadata.fromPartial(base ?? {}); + }, + fromPartial(_: DeepPartial): GenerativeAnyscaleMetadata { + const message = createBaseGenerativeAnyscaleMetadata(); + return message; + }, +}; + +function createBaseGenerativeAWSMetadata(): GenerativeAWSMetadata { + return {}; +} + +export const GenerativeAWSMetadata = { + encode(_: GenerativeAWSMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeAWSMetadata { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeAWSMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(_: any): GenerativeAWSMetadata { + return {}; + }, + + toJSON(_: GenerativeAWSMetadata): unknown { + const obj: any = {}; + return obj; + }, + + create(base?: DeepPartial): GenerativeAWSMetadata { + return GenerativeAWSMetadata.fromPartial(base ?? {}); + }, + fromPartial(_: DeepPartial): GenerativeAWSMetadata { + const message = createBaseGenerativeAWSMetadata(); + return message; + }, +}; + +function createBaseGenerativeCohereMetadata(): GenerativeCohereMetadata { + return { apiVersion: undefined, billedUnits: undefined, tokens: undefined, warnings: undefined }; +} + +export const GenerativeCohereMetadata = { + encode(message: GenerativeCohereMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.apiVersion !== undefined) { + GenerativeCohereMetadata_ApiVersion.encode(message.apiVersion, writer.uint32(10).fork()).ldelim(); + } + if (message.billedUnits !== undefined) { + GenerativeCohereMetadata_BilledUnits.encode(message.billedUnits, writer.uint32(18).fork()).ldelim(); + } + if (message.tokens !== undefined) { + GenerativeCohereMetadata_Tokens.encode(message.tokens, writer.uint32(26).fork()).ldelim(); + } + if (message.warnings !== undefined) { + TextArray.encode(message.warnings, writer.uint32(34).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeCohereMetadata { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeCohereMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.apiVersion = GenerativeCohereMetadata_ApiVersion.decode(reader, reader.uint32()); + continue; + case 2: + if (tag !== 18) { + break; + } + + message.billedUnits = GenerativeCohereMetadata_BilledUnits.decode(reader, reader.uint32()); + continue; + case 3: + if (tag !== 26) { + break; + } + + message.tokens = GenerativeCohereMetadata_Tokens.decode(reader, reader.uint32()); + continue; + case 4: + if (tag !== 34) { + break; + } + + message.warnings = TextArray.decode(reader, reader.uint32()); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeCohereMetadata { + return { + apiVersion: isSet(object.apiVersion) + ? GenerativeCohereMetadata_ApiVersion.fromJSON(object.apiVersion) + : undefined, + billedUnits: isSet(object.billedUnits) + ? GenerativeCohereMetadata_BilledUnits.fromJSON(object.billedUnits) + : undefined, + tokens: isSet(object.tokens) ? GenerativeCohereMetadata_Tokens.fromJSON(object.tokens) : undefined, + warnings: isSet(object.warnings) ? TextArray.fromJSON(object.warnings) : undefined, + }; + }, + + toJSON(message: GenerativeCohereMetadata): unknown { + const obj: any = {}; + if (message.apiVersion !== undefined) { + obj.apiVersion = GenerativeCohereMetadata_ApiVersion.toJSON(message.apiVersion); + } + if (message.billedUnits !== undefined) { + obj.billedUnits = GenerativeCohereMetadata_BilledUnits.toJSON(message.billedUnits); + } + if (message.tokens !== undefined) { + obj.tokens = GenerativeCohereMetadata_Tokens.toJSON(message.tokens); + } + if (message.warnings !== undefined) { + obj.warnings = TextArray.toJSON(message.warnings); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeCohereMetadata { + return GenerativeCohereMetadata.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeCohereMetadata { + const message = createBaseGenerativeCohereMetadata(); + message.apiVersion = (object.apiVersion !== undefined && object.apiVersion !== null) + ? GenerativeCohereMetadata_ApiVersion.fromPartial(object.apiVersion) + : undefined; + message.billedUnits = (object.billedUnits !== undefined && object.billedUnits !== null) + ? GenerativeCohereMetadata_BilledUnits.fromPartial(object.billedUnits) + : undefined; + message.tokens = (object.tokens !== undefined && object.tokens !== null) + ? GenerativeCohereMetadata_Tokens.fromPartial(object.tokens) + : undefined; + message.warnings = (object.warnings !== undefined && object.warnings !== null) + ? TextArray.fromPartial(object.warnings) + : undefined; + return message; + }, +}; + +function createBaseGenerativeCohereMetadata_ApiVersion(): GenerativeCohereMetadata_ApiVersion { + return { version: undefined, isDeprecated: undefined, isExperimental: undefined }; +} + +export const GenerativeCohereMetadata_ApiVersion = { + encode(message: GenerativeCohereMetadata_ApiVersion, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.version !== undefined) { + writer.uint32(10).string(message.version); + } + if (message.isDeprecated !== undefined) { + writer.uint32(16).bool(message.isDeprecated); + } + if (message.isExperimental !== undefined) { + writer.uint32(24).bool(message.isExperimental); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeCohereMetadata_ApiVersion { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeCohereMetadata_ApiVersion(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.version = reader.string(); + continue; + case 2: + if (tag !== 16) { + break; + } + + message.isDeprecated = reader.bool(); + continue; + case 3: + if (tag !== 24) { + break; + } + + message.isExperimental = reader.bool(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeCohereMetadata_ApiVersion { + return { + version: isSet(object.version) ? globalThis.String(object.version) : undefined, + isDeprecated: isSet(object.isDeprecated) ? globalThis.Boolean(object.isDeprecated) : undefined, + isExperimental: isSet(object.isExperimental) ? globalThis.Boolean(object.isExperimental) : undefined, + }; + }, + + toJSON(message: GenerativeCohereMetadata_ApiVersion): unknown { + const obj: any = {}; + if (message.version !== undefined) { + obj.version = message.version; + } + if (message.isDeprecated !== undefined) { + obj.isDeprecated = message.isDeprecated; + } + if (message.isExperimental !== undefined) { + obj.isExperimental = message.isExperimental; + } + return obj; + }, + + create(base?: DeepPartial): GenerativeCohereMetadata_ApiVersion { + return GenerativeCohereMetadata_ApiVersion.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeCohereMetadata_ApiVersion { + const message = createBaseGenerativeCohereMetadata_ApiVersion(); + message.version = object.version ?? undefined; + message.isDeprecated = object.isDeprecated ?? undefined; + message.isExperimental = object.isExperimental ?? undefined; + return message; + }, +}; + +function createBaseGenerativeCohereMetadata_BilledUnits(): GenerativeCohereMetadata_BilledUnits { + return { inputTokens: undefined, outputTokens: undefined, searchUnits: undefined, classifications: undefined }; +} + +export const GenerativeCohereMetadata_BilledUnits = { + encode(message: GenerativeCohereMetadata_BilledUnits, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.inputTokens !== undefined) { + writer.uint32(9).double(message.inputTokens); + } + if (message.outputTokens !== undefined) { + writer.uint32(17).double(message.outputTokens); + } + if (message.searchUnits !== undefined) { + writer.uint32(25).double(message.searchUnits); + } + if (message.classifications !== undefined) { + writer.uint32(33).double(message.classifications); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeCohereMetadata_BilledUnits { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeCohereMetadata_BilledUnits(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 9) { + break; + } + + message.inputTokens = reader.double(); + continue; + case 2: + if (tag !== 17) { + break; + } + + message.outputTokens = reader.double(); + continue; + case 3: + if (tag !== 25) { + break; + } + + message.searchUnits = reader.double(); + continue; + case 4: + if (tag !== 33) { + break; + } + + message.classifications = reader.double(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeCohereMetadata_BilledUnits { + return { + inputTokens: isSet(object.inputTokens) ? globalThis.Number(object.inputTokens) : undefined, + outputTokens: isSet(object.outputTokens) ? globalThis.Number(object.outputTokens) : undefined, + searchUnits: isSet(object.searchUnits) ? globalThis.Number(object.searchUnits) : undefined, + classifications: isSet(object.classifications) ? globalThis.Number(object.classifications) : undefined, + }; + }, + + toJSON(message: GenerativeCohereMetadata_BilledUnits): unknown { + const obj: any = {}; + if (message.inputTokens !== undefined) { + obj.inputTokens = message.inputTokens; + } + if (message.outputTokens !== undefined) { + obj.outputTokens = message.outputTokens; + } + if (message.searchUnits !== undefined) { + obj.searchUnits = message.searchUnits; + } + if (message.classifications !== undefined) { + obj.classifications = message.classifications; + } + return obj; + }, + + create(base?: DeepPartial): GenerativeCohereMetadata_BilledUnits { + return GenerativeCohereMetadata_BilledUnits.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeCohereMetadata_BilledUnits { + const message = createBaseGenerativeCohereMetadata_BilledUnits(); + message.inputTokens = object.inputTokens ?? undefined; + message.outputTokens = object.outputTokens ?? undefined; + message.searchUnits = object.searchUnits ?? undefined; + message.classifications = object.classifications ?? undefined; + return message; + }, +}; + +function createBaseGenerativeCohereMetadata_Tokens(): GenerativeCohereMetadata_Tokens { + return { inputTokens: undefined, outputTokens: undefined }; +} + +export const GenerativeCohereMetadata_Tokens = { + encode(message: GenerativeCohereMetadata_Tokens, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.inputTokens !== undefined) { + writer.uint32(9).double(message.inputTokens); + } + if (message.outputTokens !== undefined) { + writer.uint32(17).double(message.outputTokens); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeCohereMetadata_Tokens { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeCohereMetadata_Tokens(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 9) { + break; + } + + message.inputTokens = reader.double(); + continue; + case 2: + if (tag !== 17) { + break; + } + + message.outputTokens = reader.double(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeCohereMetadata_Tokens { + return { + inputTokens: isSet(object.inputTokens) ? globalThis.Number(object.inputTokens) : undefined, + outputTokens: isSet(object.outputTokens) ? globalThis.Number(object.outputTokens) : undefined, + }; + }, + + toJSON(message: GenerativeCohereMetadata_Tokens): unknown { + const obj: any = {}; + if (message.inputTokens !== undefined) { + obj.inputTokens = message.inputTokens; + } + if (message.outputTokens !== undefined) { + obj.outputTokens = message.outputTokens; + } + return obj; + }, + + create(base?: DeepPartial): GenerativeCohereMetadata_Tokens { + return GenerativeCohereMetadata_Tokens.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeCohereMetadata_Tokens { + const message = createBaseGenerativeCohereMetadata_Tokens(); + message.inputTokens = object.inputTokens ?? undefined; + message.outputTokens = object.outputTokens ?? undefined; + return message; + }, +}; + +function createBaseGenerativeDummyMetadata(): GenerativeDummyMetadata { + return {}; +} + +export const GenerativeDummyMetadata = { + encode(_: GenerativeDummyMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeDummyMetadata { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeDummyMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(_: any): GenerativeDummyMetadata { + return {}; + }, + + toJSON(_: GenerativeDummyMetadata): unknown { + const obj: any = {}; + return obj; + }, + + create(base?: DeepPartial): GenerativeDummyMetadata { + return GenerativeDummyMetadata.fromPartial(base ?? {}); + }, + fromPartial(_: DeepPartial): GenerativeDummyMetadata { + const message = createBaseGenerativeDummyMetadata(); + return message; + }, +}; + +function createBaseGenerativeMistralMetadata(): GenerativeMistralMetadata { + return { usage: undefined }; +} + +export const GenerativeMistralMetadata = { + encode(message: GenerativeMistralMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.usage !== undefined) { + GenerativeMistralMetadata_Usage.encode(message.usage, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeMistralMetadata { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeMistralMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.usage = GenerativeMistralMetadata_Usage.decode(reader, reader.uint32()); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeMistralMetadata { + return { usage: isSet(object.usage) ? GenerativeMistralMetadata_Usage.fromJSON(object.usage) : undefined }; + }, + + toJSON(message: GenerativeMistralMetadata): unknown { + const obj: any = {}; + if (message.usage !== undefined) { + obj.usage = GenerativeMistralMetadata_Usage.toJSON(message.usage); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeMistralMetadata { + return GenerativeMistralMetadata.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeMistralMetadata { + const message = createBaseGenerativeMistralMetadata(); + message.usage = (object.usage !== undefined && object.usage !== null) + ? GenerativeMistralMetadata_Usage.fromPartial(object.usage) + : undefined; + return message; + }, +}; + +function createBaseGenerativeMistralMetadata_Usage(): GenerativeMistralMetadata_Usage { + return { promptTokens: undefined, completionTokens: undefined, totalTokens: undefined }; +} + +export const GenerativeMistralMetadata_Usage = { + encode(message: GenerativeMistralMetadata_Usage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.promptTokens !== undefined) { + writer.uint32(8).int64(message.promptTokens); + } + if (message.completionTokens !== undefined) { + writer.uint32(16).int64(message.completionTokens); + } + if (message.totalTokens !== undefined) { + writer.uint32(24).int64(message.totalTokens); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeMistralMetadata_Usage { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeMistralMetadata_Usage(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 8) { + break; + } + + message.promptTokens = longToNumber(reader.int64() as Long); + continue; + case 2: + if (tag !== 16) { + break; + } + + message.completionTokens = longToNumber(reader.int64() as Long); + continue; + case 3: + if (tag !== 24) { + break; + } + + message.totalTokens = longToNumber(reader.int64() as Long); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeMistralMetadata_Usage { + return { + promptTokens: isSet(object.promptTokens) ? globalThis.Number(object.promptTokens) : undefined, + completionTokens: isSet(object.completionTokens) ? globalThis.Number(object.completionTokens) : undefined, + totalTokens: isSet(object.totalTokens) ? globalThis.Number(object.totalTokens) : undefined, + }; + }, + + toJSON(message: GenerativeMistralMetadata_Usage): unknown { + const obj: any = {}; + if (message.promptTokens !== undefined) { + obj.promptTokens = Math.round(message.promptTokens); + } + if (message.completionTokens !== undefined) { + obj.completionTokens = Math.round(message.completionTokens); + } + if (message.totalTokens !== undefined) { + obj.totalTokens = Math.round(message.totalTokens); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeMistralMetadata_Usage { + return GenerativeMistralMetadata_Usage.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeMistralMetadata_Usage { + const message = createBaseGenerativeMistralMetadata_Usage(); + message.promptTokens = object.promptTokens ?? undefined; + message.completionTokens = object.completionTokens ?? undefined; + message.totalTokens = object.totalTokens ?? undefined; + return message; + }, +}; + +function createBaseGenerativeOctoAIMetadata(): GenerativeOctoAIMetadata { + return { usage: undefined }; +} + +export const GenerativeOctoAIMetadata = { + encode(message: GenerativeOctoAIMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.usage !== undefined) { + GenerativeOctoAIMetadata_Usage.encode(message.usage, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeOctoAIMetadata { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeOctoAIMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.usage = GenerativeOctoAIMetadata_Usage.decode(reader, reader.uint32()); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeOctoAIMetadata { + return { usage: isSet(object.usage) ? GenerativeOctoAIMetadata_Usage.fromJSON(object.usage) : undefined }; + }, + + toJSON(message: GenerativeOctoAIMetadata): unknown { + const obj: any = {}; + if (message.usage !== undefined) { + obj.usage = GenerativeOctoAIMetadata_Usage.toJSON(message.usage); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeOctoAIMetadata { + return GenerativeOctoAIMetadata.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeOctoAIMetadata { + const message = createBaseGenerativeOctoAIMetadata(); + message.usage = (object.usage !== undefined && object.usage !== null) + ? GenerativeOctoAIMetadata_Usage.fromPartial(object.usage) + : undefined; + return message; + }, +}; + +function createBaseGenerativeOctoAIMetadata_Usage(): GenerativeOctoAIMetadata_Usage { + return { promptTokens: undefined, completionTokens: undefined, totalTokens: undefined }; +} + +export const GenerativeOctoAIMetadata_Usage = { + encode(message: GenerativeOctoAIMetadata_Usage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.promptTokens !== undefined) { + writer.uint32(8).int64(message.promptTokens); + } + if (message.completionTokens !== undefined) { + writer.uint32(16).int64(message.completionTokens); + } + if (message.totalTokens !== undefined) { + writer.uint32(24).int64(message.totalTokens); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeOctoAIMetadata_Usage { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeOctoAIMetadata_Usage(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 8) { + break; + } + + message.promptTokens = longToNumber(reader.int64() as Long); + continue; + case 2: + if (tag !== 16) { + break; + } + + message.completionTokens = longToNumber(reader.int64() as Long); + continue; + case 3: + if (tag !== 24) { + break; + } + + message.totalTokens = longToNumber(reader.int64() as Long); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeOctoAIMetadata_Usage { + return { + promptTokens: isSet(object.promptTokens) ? globalThis.Number(object.promptTokens) : undefined, + completionTokens: isSet(object.completionTokens) ? globalThis.Number(object.completionTokens) : undefined, + totalTokens: isSet(object.totalTokens) ? globalThis.Number(object.totalTokens) : undefined, + }; + }, + + toJSON(message: GenerativeOctoAIMetadata_Usage): unknown { + const obj: any = {}; + if (message.promptTokens !== undefined) { + obj.promptTokens = Math.round(message.promptTokens); + } + if (message.completionTokens !== undefined) { + obj.completionTokens = Math.round(message.completionTokens); + } + if (message.totalTokens !== undefined) { + obj.totalTokens = Math.round(message.totalTokens); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeOctoAIMetadata_Usage { + return GenerativeOctoAIMetadata_Usage.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeOctoAIMetadata_Usage { + const message = createBaseGenerativeOctoAIMetadata_Usage(); + message.promptTokens = object.promptTokens ?? undefined; + message.completionTokens = object.completionTokens ?? undefined; + message.totalTokens = object.totalTokens ?? undefined; + return message; + }, +}; + +function createBaseGenerativeOllamaMetadata(): GenerativeOllamaMetadata { + return {}; +} + +export const GenerativeOllamaMetadata = { + encode(_: GenerativeOllamaMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeOllamaMetadata { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeOllamaMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(_: any): GenerativeOllamaMetadata { + return {}; + }, + + toJSON(_: GenerativeOllamaMetadata): unknown { + const obj: any = {}; + return obj; + }, + + create(base?: DeepPartial): GenerativeOllamaMetadata { + return GenerativeOllamaMetadata.fromPartial(base ?? {}); + }, + fromPartial(_: DeepPartial): GenerativeOllamaMetadata { + const message = createBaseGenerativeOllamaMetadata(); + return message; + }, +}; + +function createBaseGenerativeOpenAIMetadata(): GenerativeOpenAIMetadata { + return { usage: undefined }; +} + +export const GenerativeOpenAIMetadata = { + encode(message: GenerativeOpenAIMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.usage !== undefined) { + GenerativeOpenAIMetadata_Usage.encode(message.usage, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeOpenAIMetadata { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeOpenAIMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.usage = GenerativeOpenAIMetadata_Usage.decode(reader, reader.uint32()); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeOpenAIMetadata { + return { usage: isSet(object.usage) ? GenerativeOpenAIMetadata_Usage.fromJSON(object.usage) : undefined }; + }, + + toJSON(message: GenerativeOpenAIMetadata): unknown { + const obj: any = {}; + if (message.usage !== undefined) { + obj.usage = GenerativeOpenAIMetadata_Usage.toJSON(message.usage); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeOpenAIMetadata { + return GenerativeOpenAIMetadata.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeOpenAIMetadata { + const message = createBaseGenerativeOpenAIMetadata(); + message.usage = (object.usage !== undefined && object.usage !== null) + ? GenerativeOpenAIMetadata_Usage.fromPartial(object.usage) + : undefined; + return message; + }, +}; + +function createBaseGenerativeOpenAIMetadata_Usage(): GenerativeOpenAIMetadata_Usage { + return { promptTokens: undefined, completionTokens: undefined, totalTokens: undefined }; +} + +export const GenerativeOpenAIMetadata_Usage = { + encode(message: GenerativeOpenAIMetadata_Usage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.promptTokens !== undefined) { + writer.uint32(8).int64(message.promptTokens); + } + if (message.completionTokens !== undefined) { + writer.uint32(16).int64(message.completionTokens); + } + if (message.totalTokens !== undefined) { + writer.uint32(24).int64(message.totalTokens); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeOpenAIMetadata_Usage { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeOpenAIMetadata_Usage(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 8) { + break; + } + + message.promptTokens = longToNumber(reader.int64() as Long); + continue; + case 2: + if (tag !== 16) { + break; + } + + message.completionTokens = longToNumber(reader.int64() as Long); + continue; + case 3: + if (tag !== 24) { + break; + } + + message.totalTokens = longToNumber(reader.int64() as Long); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeOpenAIMetadata_Usage { + return { + promptTokens: isSet(object.promptTokens) ? globalThis.Number(object.promptTokens) : undefined, + completionTokens: isSet(object.completionTokens) ? globalThis.Number(object.completionTokens) : undefined, + totalTokens: isSet(object.totalTokens) ? globalThis.Number(object.totalTokens) : undefined, + }; + }, + + toJSON(message: GenerativeOpenAIMetadata_Usage): unknown { + const obj: any = {}; + if (message.promptTokens !== undefined) { + obj.promptTokens = Math.round(message.promptTokens); + } + if (message.completionTokens !== undefined) { + obj.completionTokens = Math.round(message.completionTokens); + } + if (message.totalTokens !== undefined) { + obj.totalTokens = Math.round(message.totalTokens); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeOpenAIMetadata_Usage { + return GenerativeOpenAIMetadata_Usage.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeOpenAIMetadata_Usage { + const message = createBaseGenerativeOpenAIMetadata_Usage(); + message.promptTokens = object.promptTokens ?? undefined; + message.completionTokens = object.completionTokens ?? undefined; + message.totalTokens = object.totalTokens ?? undefined; + return message; + }, +}; + +function createBaseGenerativeGoogleMetadata(): GenerativeGoogleMetadata { + return { metadata: undefined, usageMetadata: undefined }; +} + +export const GenerativeGoogleMetadata = { + encode(message: GenerativeGoogleMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.metadata !== undefined) { + GenerativeGoogleMetadata_Metadata.encode(message.metadata, writer.uint32(10).fork()).ldelim(); + } + if (message.usageMetadata !== undefined) { + GenerativeGoogleMetadata_UsageMetadata.encode(message.usageMetadata, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeGoogleMetadata { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeGoogleMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.metadata = GenerativeGoogleMetadata_Metadata.decode(reader, reader.uint32()); + continue; + case 2: + if (tag !== 18) { + break; + } + + message.usageMetadata = GenerativeGoogleMetadata_UsageMetadata.decode(reader, reader.uint32()); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeGoogleMetadata { + return { + metadata: isSet(object.metadata) ? GenerativeGoogleMetadata_Metadata.fromJSON(object.metadata) : undefined, + usageMetadata: isSet(object.usageMetadata) + ? GenerativeGoogleMetadata_UsageMetadata.fromJSON(object.usageMetadata) + : undefined, + }; + }, + + toJSON(message: GenerativeGoogleMetadata): unknown { + const obj: any = {}; + if (message.metadata !== undefined) { + obj.metadata = GenerativeGoogleMetadata_Metadata.toJSON(message.metadata); + } + if (message.usageMetadata !== undefined) { + obj.usageMetadata = GenerativeGoogleMetadata_UsageMetadata.toJSON(message.usageMetadata); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeGoogleMetadata { + return GenerativeGoogleMetadata.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeGoogleMetadata { + const message = createBaseGenerativeGoogleMetadata(); + message.metadata = (object.metadata !== undefined && object.metadata !== null) + ? GenerativeGoogleMetadata_Metadata.fromPartial(object.metadata) + : undefined; + message.usageMetadata = (object.usageMetadata !== undefined && object.usageMetadata !== null) + ? GenerativeGoogleMetadata_UsageMetadata.fromPartial(object.usageMetadata) + : undefined; + return message; + }, +}; + +function createBaseGenerativeGoogleMetadata_TokenCount(): GenerativeGoogleMetadata_TokenCount { + return { totalBillableCharacters: undefined, totalTokens: undefined }; +} + +export const GenerativeGoogleMetadata_TokenCount = { + encode(message: GenerativeGoogleMetadata_TokenCount, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.totalBillableCharacters !== undefined) { + writer.uint32(8).int64(message.totalBillableCharacters); + } + if (message.totalTokens !== undefined) { + writer.uint32(16).int64(message.totalTokens); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeGoogleMetadata_TokenCount { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeGoogleMetadata_TokenCount(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 8) { + break; + } + + message.totalBillableCharacters = longToNumber(reader.int64() as Long); + continue; + case 2: + if (tag !== 16) { + break; + } + + message.totalTokens = longToNumber(reader.int64() as Long); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeGoogleMetadata_TokenCount { + return { + totalBillableCharacters: isSet(object.totalBillableCharacters) + ? globalThis.Number(object.totalBillableCharacters) + : undefined, + totalTokens: isSet(object.totalTokens) ? globalThis.Number(object.totalTokens) : undefined, + }; + }, + + toJSON(message: GenerativeGoogleMetadata_TokenCount): unknown { + const obj: any = {}; + if (message.totalBillableCharacters !== undefined) { + obj.totalBillableCharacters = Math.round(message.totalBillableCharacters); + } + if (message.totalTokens !== undefined) { + obj.totalTokens = Math.round(message.totalTokens); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeGoogleMetadata_TokenCount { + return GenerativeGoogleMetadata_TokenCount.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeGoogleMetadata_TokenCount { + const message = createBaseGenerativeGoogleMetadata_TokenCount(); + message.totalBillableCharacters = object.totalBillableCharacters ?? undefined; + message.totalTokens = object.totalTokens ?? undefined; + return message; + }, +}; + +function createBaseGenerativeGoogleMetadata_TokenMetadata(): GenerativeGoogleMetadata_TokenMetadata { + return { inputTokenCount: undefined, outputTokenCount: undefined }; +} + +export const GenerativeGoogleMetadata_TokenMetadata = { + encode(message: GenerativeGoogleMetadata_TokenMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.inputTokenCount !== undefined) { + GenerativeGoogleMetadata_TokenCount.encode(message.inputTokenCount, writer.uint32(10).fork()).ldelim(); + } + if (message.outputTokenCount !== undefined) { + GenerativeGoogleMetadata_TokenCount.encode(message.outputTokenCount, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeGoogleMetadata_TokenMetadata { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeGoogleMetadata_TokenMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.inputTokenCount = GenerativeGoogleMetadata_TokenCount.decode(reader, reader.uint32()); + continue; + case 2: + if (tag !== 18) { + break; + } + + message.outputTokenCount = GenerativeGoogleMetadata_TokenCount.decode(reader, reader.uint32()); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeGoogleMetadata_TokenMetadata { + return { + inputTokenCount: isSet(object.inputTokenCount) + ? GenerativeGoogleMetadata_TokenCount.fromJSON(object.inputTokenCount) + : undefined, + outputTokenCount: isSet(object.outputTokenCount) + ? GenerativeGoogleMetadata_TokenCount.fromJSON(object.outputTokenCount) + : undefined, + }; + }, + + toJSON(message: GenerativeGoogleMetadata_TokenMetadata): unknown { + const obj: any = {}; + if (message.inputTokenCount !== undefined) { + obj.inputTokenCount = GenerativeGoogleMetadata_TokenCount.toJSON(message.inputTokenCount); + } + if (message.outputTokenCount !== undefined) { + obj.outputTokenCount = GenerativeGoogleMetadata_TokenCount.toJSON(message.outputTokenCount); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeGoogleMetadata_TokenMetadata { + return GenerativeGoogleMetadata_TokenMetadata.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeGoogleMetadata_TokenMetadata { + const message = createBaseGenerativeGoogleMetadata_TokenMetadata(); + message.inputTokenCount = (object.inputTokenCount !== undefined && object.inputTokenCount !== null) + ? GenerativeGoogleMetadata_TokenCount.fromPartial(object.inputTokenCount) + : undefined; + message.outputTokenCount = (object.outputTokenCount !== undefined && object.outputTokenCount !== null) + ? GenerativeGoogleMetadata_TokenCount.fromPartial(object.outputTokenCount) + : undefined; + return message; + }, +}; + +function createBaseGenerativeGoogleMetadata_Metadata(): GenerativeGoogleMetadata_Metadata { + return { tokenMetadata: undefined }; +} + +export const GenerativeGoogleMetadata_Metadata = { + encode(message: GenerativeGoogleMetadata_Metadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.tokenMetadata !== undefined) { + GenerativeGoogleMetadata_TokenMetadata.encode(message.tokenMetadata, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeGoogleMetadata_Metadata { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeGoogleMetadata_Metadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.tokenMetadata = GenerativeGoogleMetadata_TokenMetadata.decode(reader, reader.uint32()); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeGoogleMetadata_Metadata { + return { + tokenMetadata: isSet(object.tokenMetadata) + ? GenerativeGoogleMetadata_TokenMetadata.fromJSON(object.tokenMetadata) + : undefined, + }; + }, + + toJSON(message: GenerativeGoogleMetadata_Metadata): unknown { + const obj: any = {}; + if (message.tokenMetadata !== undefined) { + obj.tokenMetadata = GenerativeGoogleMetadata_TokenMetadata.toJSON(message.tokenMetadata); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeGoogleMetadata_Metadata { + return GenerativeGoogleMetadata_Metadata.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeGoogleMetadata_Metadata { + const message = createBaseGenerativeGoogleMetadata_Metadata(); + message.tokenMetadata = (object.tokenMetadata !== undefined && object.tokenMetadata !== null) + ? GenerativeGoogleMetadata_TokenMetadata.fromPartial(object.tokenMetadata) + : undefined; + return message; + }, +}; + +function createBaseGenerativeGoogleMetadata_UsageMetadata(): GenerativeGoogleMetadata_UsageMetadata { + return { promptTokenCount: undefined, candidatesTokenCount: undefined, totalTokenCount: undefined }; +} + +export const GenerativeGoogleMetadata_UsageMetadata = { + encode(message: GenerativeGoogleMetadata_UsageMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.promptTokenCount !== undefined) { + writer.uint32(8).int64(message.promptTokenCount); + } + if (message.candidatesTokenCount !== undefined) { + writer.uint32(16).int64(message.candidatesTokenCount); + } + if (message.totalTokenCount !== undefined) { + writer.uint32(24).int64(message.totalTokenCount); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeGoogleMetadata_UsageMetadata { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeGoogleMetadata_UsageMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 8) { + break; + } + + message.promptTokenCount = longToNumber(reader.int64() as Long); + continue; + case 2: + if (tag !== 16) { + break; + } + + message.candidatesTokenCount = longToNumber(reader.int64() as Long); + continue; + case 3: + if (tag !== 24) { + break; + } + + message.totalTokenCount = longToNumber(reader.int64() as Long); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeGoogleMetadata_UsageMetadata { + return { + promptTokenCount: isSet(object.promptTokenCount) ? globalThis.Number(object.promptTokenCount) : undefined, + candidatesTokenCount: isSet(object.candidatesTokenCount) + ? globalThis.Number(object.candidatesTokenCount) + : undefined, + totalTokenCount: isSet(object.totalTokenCount) ? globalThis.Number(object.totalTokenCount) : undefined, + }; + }, + + toJSON(message: GenerativeGoogleMetadata_UsageMetadata): unknown { + const obj: any = {}; + if (message.promptTokenCount !== undefined) { + obj.promptTokenCount = Math.round(message.promptTokenCount); + } + if (message.candidatesTokenCount !== undefined) { + obj.candidatesTokenCount = Math.round(message.candidatesTokenCount); + } + if (message.totalTokenCount !== undefined) { + obj.totalTokenCount = Math.round(message.totalTokenCount); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeGoogleMetadata_UsageMetadata { + return GenerativeGoogleMetadata_UsageMetadata.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeGoogleMetadata_UsageMetadata { + const message = createBaseGenerativeGoogleMetadata_UsageMetadata(); + message.promptTokenCount = object.promptTokenCount ?? undefined; + message.candidatesTokenCount = object.candidatesTokenCount ?? undefined; + message.totalTokenCount = object.totalTokenCount ?? undefined; + return message; + }, +}; + +function createBaseGenerativeMetadata(): GenerativeMetadata { + return { + anthropic: undefined, + anyscale: undefined, + aws: undefined, + cohere: undefined, + dummy: undefined, + mistral: undefined, + octoai: undefined, + ollama: undefined, + openai: undefined, + google: undefined, + }; +} + +export const GenerativeMetadata = { + encode(message: GenerativeMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.anthropic !== undefined) { + GenerativeAnthropicMetadata.encode(message.anthropic, writer.uint32(10).fork()).ldelim(); + } + if (message.anyscale !== undefined) { + GenerativeAnyscaleMetadata.encode(message.anyscale, writer.uint32(18).fork()).ldelim(); + } + if (message.aws !== undefined) { + GenerativeAWSMetadata.encode(message.aws, writer.uint32(26).fork()).ldelim(); + } + if (message.cohere !== undefined) { + GenerativeCohereMetadata.encode(message.cohere, writer.uint32(34).fork()).ldelim(); + } + if (message.dummy !== undefined) { + GenerativeDummyMetadata.encode(message.dummy, writer.uint32(42).fork()).ldelim(); + } + if (message.mistral !== undefined) { + GenerativeMistralMetadata.encode(message.mistral, writer.uint32(50).fork()).ldelim(); + } + if (message.octoai !== undefined) { + GenerativeOctoAIMetadata.encode(message.octoai, writer.uint32(58).fork()).ldelim(); + } + if (message.ollama !== undefined) { + GenerativeOllamaMetadata.encode(message.ollama, writer.uint32(66).fork()).ldelim(); + } + if (message.openai !== undefined) { + GenerativeOpenAIMetadata.encode(message.openai, writer.uint32(74).fork()).ldelim(); + } + if (message.google !== undefined) { + GenerativeGoogleMetadata.encode(message.google, writer.uint32(82).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeMetadata { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.anthropic = GenerativeAnthropicMetadata.decode(reader, reader.uint32()); + continue; + case 2: + if (tag !== 18) { + break; + } + + message.anyscale = GenerativeAnyscaleMetadata.decode(reader, reader.uint32()); + continue; + case 3: + if (tag !== 26) { + break; + } + + message.aws = GenerativeAWSMetadata.decode(reader, reader.uint32()); + continue; + case 4: + if (tag !== 34) { + break; + } + + message.cohere = GenerativeCohereMetadata.decode(reader, reader.uint32()); + continue; + case 5: + if (tag !== 42) { + break; + } + + message.dummy = GenerativeDummyMetadata.decode(reader, reader.uint32()); + continue; + case 6: + if (tag !== 50) { + break; + } + + message.mistral = GenerativeMistralMetadata.decode(reader, reader.uint32()); + continue; + case 7: + if (tag !== 58) { + break; + } + + message.octoai = GenerativeOctoAIMetadata.decode(reader, reader.uint32()); + continue; + case 8: + if (tag !== 66) { + break; + } + + message.ollama = GenerativeOllamaMetadata.decode(reader, reader.uint32()); + continue; + case 9: + if (tag !== 74) { + break; + } + + message.openai = GenerativeOpenAIMetadata.decode(reader, reader.uint32()); + continue; + case 10: + if (tag !== 82) { + break; + } + + message.google = GenerativeGoogleMetadata.decode(reader, reader.uint32()); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeMetadata { + return { + anthropic: isSet(object.anthropic) ? GenerativeAnthropicMetadata.fromJSON(object.anthropic) : undefined, + anyscale: isSet(object.anyscale) ? GenerativeAnyscaleMetadata.fromJSON(object.anyscale) : undefined, + aws: isSet(object.aws) ? GenerativeAWSMetadata.fromJSON(object.aws) : undefined, + cohere: isSet(object.cohere) ? GenerativeCohereMetadata.fromJSON(object.cohere) : undefined, + dummy: isSet(object.dummy) ? GenerativeDummyMetadata.fromJSON(object.dummy) : undefined, + mistral: isSet(object.mistral) ? GenerativeMistralMetadata.fromJSON(object.mistral) : undefined, + octoai: isSet(object.octoai) ? GenerativeOctoAIMetadata.fromJSON(object.octoai) : undefined, + ollama: isSet(object.ollama) ? GenerativeOllamaMetadata.fromJSON(object.ollama) : undefined, + openai: isSet(object.openai) ? GenerativeOpenAIMetadata.fromJSON(object.openai) : undefined, + google: isSet(object.google) ? GenerativeGoogleMetadata.fromJSON(object.google) : undefined, + }; + }, + + toJSON(message: GenerativeMetadata): unknown { + const obj: any = {}; + if (message.anthropic !== undefined) { + obj.anthropic = GenerativeAnthropicMetadata.toJSON(message.anthropic); + } + if (message.anyscale !== undefined) { + obj.anyscale = GenerativeAnyscaleMetadata.toJSON(message.anyscale); + } + if (message.aws !== undefined) { + obj.aws = GenerativeAWSMetadata.toJSON(message.aws); + } + if (message.cohere !== undefined) { + obj.cohere = GenerativeCohereMetadata.toJSON(message.cohere); + } + if (message.dummy !== undefined) { + obj.dummy = GenerativeDummyMetadata.toJSON(message.dummy); + } + if (message.mistral !== undefined) { + obj.mistral = GenerativeMistralMetadata.toJSON(message.mistral); + } + if (message.octoai !== undefined) { + obj.octoai = GenerativeOctoAIMetadata.toJSON(message.octoai); + } + if (message.ollama !== undefined) { + obj.ollama = GenerativeOllamaMetadata.toJSON(message.ollama); + } + if (message.openai !== undefined) { + obj.openai = GenerativeOpenAIMetadata.toJSON(message.openai); + } + if (message.google !== undefined) { + obj.google = GenerativeGoogleMetadata.toJSON(message.google); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeMetadata { + return GenerativeMetadata.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeMetadata { + const message = createBaseGenerativeMetadata(); + message.anthropic = (object.anthropic !== undefined && object.anthropic !== null) + ? GenerativeAnthropicMetadata.fromPartial(object.anthropic) + : undefined; + message.anyscale = (object.anyscale !== undefined && object.anyscale !== null) + ? GenerativeAnyscaleMetadata.fromPartial(object.anyscale) + : undefined; + message.aws = (object.aws !== undefined && object.aws !== null) + ? GenerativeAWSMetadata.fromPartial(object.aws) + : undefined; + message.cohere = (object.cohere !== undefined && object.cohere !== null) + ? GenerativeCohereMetadata.fromPartial(object.cohere) + : undefined; + message.dummy = (object.dummy !== undefined && object.dummy !== null) + ? GenerativeDummyMetadata.fromPartial(object.dummy) + : undefined; + message.mistral = (object.mistral !== undefined && object.mistral !== null) + ? GenerativeMistralMetadata.fromPartial(object.mistral) + : undefined; + message.octoai = (object.octoai !== undefined && object.octoai !== null) + ? GenerativeOctoAIMetadata.fromPartial(object.octoai) + : undefined; + message.ollama = (object.ollama !== undefined && object.ollama !== null) + ? GenerativeOllamaMetadata.fromPartial(object.ollama) + : undefined; + message.openai = (object.openai !== undefined && object.openai !== null) + ? GenerativeOpenAIMetadata.fromPartial(object.openai) + : undefined; + message.google = (object.google !== undefined && object.google !== null) + ? GenerativeGoogleMetadata.fromPartial(object.google) + : undefined; + return message; + }, +}; + +function createBaseGenerativeReply(): GenerativeReply { + return { result: "", debug: undefined, metadata: undefined }; +} + +export const GenerativeReply = { + encode(message: GenerativeReply, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.result !== "") { + writer.uint32(10).string(message.result); + } + if (message.debug !== undefined) { + GenerativeDebug.encode(message.debug, writer.uint32(18).fork()).ldelim(); + } + if (message.metadata !== undefined) { + GenerativeMetadata.encode(message.metadata, writer.uint32(26).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeReply { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeReply(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.result = reader.string(); + continue; + case 2: + if (tag !== 18) { + break; + } + + message.debug = GenerativeDebug.decode(reader, reader.uint32()); + continue; + case 3: + if (tag !== 26) { + break; + } + + message.metadata = GenerativeMetadata.decode(reader, reader.uint32()); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeReply { + return { + result: isSet(object.result) ? globalThis.String(object.result) : "", + debug: isSet(object.debug) ? GenerativeDebug.fromJSON(object.debug) : undefined, + metadata: isSet(object.metadata) ? GenerativeMetadata.fromJSON(object.metadata) : undefined, + }; + }, + + toJSON(message: GenerativeReply): unknown { + const obj: any = {}; + if (message.result !== "") { + obj.result = message.result; + } + if (message.debug !== undefined) { + obj.debug = GenerativeDebug.toJSON(message.debug); + } + if (message.metadata !== undefined) { + obj.metadata = GenerativeMetadata.toJSON(message.metadata); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeReply { + return GenerativeReply.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeReply { + const message = createBaseGenerativeReply(); + message.result = object.result ?? ""; + message.debug = (object.debug !== undefined && object.debug !== null) + ? GenerativeDebug.fromPartial(object.debug) + : undefined; + message.metadata = (object.metadata !== undefined && object.metadata !== null) + ? GenerativeMetadata.fromPartial(object.metadata) + : undefined; + return message; + }, +}; + +function createBaseGenerativeResult(): GenerativeResult { + return { values: [] }; +} + +export const GenerativeResult = { + encode(message: GenerativeResult, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + for (const v of message.values) { + GenerativeReply.encode(v!, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeResult { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeResult(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.values.push(GenerativeReply.decode(reader, reader.uint32())); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeResult { + return { + values: globalThis.Array.isArray(object?.values) + ? object.values.map((e: any) => GenerativeReply.fromJSON(e)) + : [], + }; + }, + + toJSON(message: GenerativeResult): unknown { + const obj: any = {}; + if (message.values?.length) { + obj.values = message.values.map((e) => GenerativeReply.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): GenerativeResult { + return GenerativeResult.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeResult { + const message = createBaseGenerativeResult(); + message.values = object.values?.map((e) => GenerativeReply.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseGenerativeDebug(): GenerativeDebug { + return { fullPrompt: undefined }; +} + +export const GenerativeDebug = { + encode(message: GenerativeDebug, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.fullPrompt !== undefined) { + writer.uint32(10).string(message.fullPrompt); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeDebug { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenerativeDebug(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.fullPrompt = reader.string(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): GenerativeDebug { + return { fullPrompt: isSet(object.fullPrompt) ? globalThis.String(object.fullPrompt) : undefined }; + }, + + toJSON(message: GenerativeDebug): unknown { + const obj: any = {}; + if (message.fullPrompt !== undefined) { + obj.fullPrompt = message.fullPrompt; + } + return obj; + }, + + create(base?: DeepPartial): GenerativeDebug { + return GenerativeDebug.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GenerativeDebug { + const message = createBaseGenerativeDebug(); + message.fullPrompt = object.fullPrompt ?? undefined; + return message; + }, +}; + +type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined; + +export type DeepPartial = T extends Builtin ? T + : T extends globalThis.Array ? globalThis.Array> + : T extends ReadonlyArray ? ReadonlyArray> + : T extends {} ? { [K in keyof T]?: DeepPartial } + : Partial; + +function longToNumber(long: Long): number { + if (long.gt(globalThis.Number.MAX_SAFE_INTEGER)) { + throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER"); + } + return long.toNumber(); +} + +if (_m0.util.Long !== Long) { + _m0.util.Long = Long as any; + _m0.configure(); +} + +function isSet(value: any): boolean { + return value !== null && value !== undefined; +} diff --git a/src/proto/v1/search_get.ts b/src/proto/v1/search_get.ts index b20335b4..979279c2 100644 --- a/src/proto/v1/search_get.ts +++ b/src/proto/v1/search_get.ts @@ -21,6 +21,7 @@ import { TextArrayProperties, Vectors, } from "./base.js"; +import { GenerativeReply, GenerativeResult, GenerativeSearch } from "./generative.js"; import { Properties } from "./properties.js"; export const protobufPackage = "weaviate.v1"; @@ -122,7 +123,9 @@ export interface SearchRequest { | undefined; /** @deprecated */ uses123Api: boolean; + /** @deprecated */ uses125Api: boolean; + uses127Api: boolean; } export interface GroupBy { @@ -147,12 +150,6 @@ export interface SortBy { path: string[]; } -export interface GenerativeSearch { - singleResponsePrompt: string; - groupedResponseTask: string; - groupedProperties: string[]; -} - export interface MetadataRequest { uuid: boolean; vector: boolean; @@ -179,10 +176,21 @@ export interface ObjectPropertiesRequest { objectProperties: ObjectPropertiesRequest[]; } +export interface WeightsForTarget { + target: string; + weight: number; +} + export interface Targets { targetVectors: string[]; combination: CombinationMethod; + /** + * deprecated in 1.26.2 - use weights_for_targets + * + * @deprecated + */ weights: { [key: string]: number }; + weightsForTargets: WeightsForTarget[]; } export interface Targets_WeightsEntry { @@ -215,6 +223,7 @@ export interface Hybrid { /** same as above. Use the target vector in the hybrid message */ nearVector: NearVector | undefined; targets: Targets | undefined; + vectorDistance?: number | undefined; } export enum Hybrid_FusionType { @@ -382,6 +391,11 @@ export interface RefPropertiesRequest { targetCollection: string; } +export interface VectorForTarget { + name: string; + vectorBytes: Uint8Array; +} + export interface NearVector { /** * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED @@ -398,8 +412,16 @@ export interface NearVector { * @deprecated */ targetVectors: string[]; - targets: Targets | undefined; + targets: + | Targets + | undefined; + /** + * deprecated in 1.26.2 - use vector_for_targets + * + * @deprecated + */ vectorPerTarget: { [key: string]: Uint8Array }; + vectorForTargets: VectorForTarget[]; } export interface NearVector_VectorPerTargetEntry { @@ -430,31 +452,34 @@ export interface Rerank { export interface SearchReply { took: number; results: SearchResult[]; + /** @deprecated */ generativeGroupedResult?: string | undefined; groupByResults: GroupByResult[]; + generativeGroupedResults?: GenerativeResult | undefined; } export interface RerankReply { score: number; } -export interface GenerativeReply { - result: string; -} - export interface GroupByResult { name: string; minDistance: number; maxDistance: number; numberOfObjects: number; objects: SearchResult[]; - rerank?: RerankReply | undefined; + rerank?: + | RerankReply + | undefined; + /** @deprecated */ generative?: GenerativeReply | undefined; + generativeResult?: GenerativeResult | undefined; } export interface SearchResult { properties: PropertiesResult | undefined; metadata: MetadataResult | undefined; + generative?: GenerativeResult | undefined; } export interface MetadataResult { @@ -477,8 +502,12 @@ export interface MetadataResult { scorePresent: boolean; explainScore: string; explainScorePresent: boolean; - isConsistent?: boolean | undefined; + isConsistent?: + | boolean + | undefined; + /** @deprecated */ generative: string; + /** @deprecated */ generativePresent: boolean; isConsistentPresent: boolean; vectorBytes: Uint8Array; @@ -546,6 +575,7 @@ function createBaseSearchRequest(): SearchRequest { rerank: undefined, uses123Api: false, uses125Api: false, + uses127Api: false, }; } @@ -632,6 +662,9 @@ export const SearchRequest = { if (message.uses125Api !== false) { writer.uint32(808).bool(message.uses125Api); } + if (message.uses127Api !== false) { + writer.uint32(816).bool(message.uses127Api); + } return writer; }, @@ -831,6 +864,13 @@ export const SearchRequest = { message.uses125Api = reader.bool(); continue; + case 102: + if (tag !== 816) { + break; + } + + message.uses127Api = reader.bool(); + continue; } if ((tag & 7) === 4 || tag === 0) { break; @@ -869,6 +909,7 @@ export const SearchRequest = { rerank: isSet(object.rerank) ? Rerank.fromJSON(object.rerank) : undefined, uses123Api: isSet(object.uses123Api) ? globalThis.Boolean(object.uses123Api) : false, uses125Api: isSet(object.uses125Api) ? globalThis.Boolean(object.uses125Api) : false, + uses127Api: isSet(object.uses127Api) ? globalThis.Boolean(object.uses127Api) : false, }; }, @@ -955,6 +996,9 @@ export const SearchRequest = { if (message.uses125Api !== false) { obj.uses125Api = message.uses125Api; } + if (message.uses127Api !== false) { + obj.uses127Api = message.uses127Api; + } return obj; }, @@ -1024,6 +1068,7 @@ export const SearchRequest = { : undefined; message.uses123Api = object.uses123Api ?? false; message.uses125Api = object.uses125Api ?? false; + message.uses127Api = object.uses127Api ?? false; return message; }, }; @@ -1191,97 +1236,6 @@ export const SortBy = { }, }; -function createBaseGenerativeSearch(): GenerativeSearch { - return { singleResponsePrompt: "", groupedResponseTask: "", groupedProperties: [] }; -} - -export const GenerativeSearch = { - encode(message: GenerativeSearch, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { - if (message.singleResponsePrompt !== "") { - writer.uint32(10).string(message.singleResponsePrompt); - } - if (message.groupedResponseTask !== "") { - writer.uint32(18).string(message.groupedResponseTask); - } - for (const v of message.groupedProperties) { - writer.uint32(26).string(v!); - } - return writer; - }, - - decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeSearch { - const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); - let end = length === undefined ? reader.len : reader.pos + length; - const message = createBaseGenerativeSearch(); - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - if (tag !== 10) { - break; - } - - message.singleResponsePrompt = reader.string(); - continue; - case 2: - if (tag !== 18) { - break; - } - - message.groupedResponseTask = reader.string(); - continue; - case 3: - if (tag !== 26) { - break; - } - - message.groupedProperties.push(reader.string()); - continue; - } - if ((tag & 7) === 4 || tag === 0) { - break; - } - reader.skipType(tag & 7); - } - return message; - }, - - fromJSON(object: any): GenerativeSearch { - return { - singleResponsePrompt: isSet(object.singleResponsePrompt) ? globalThis.String(object.singleResponsePrompt) : "", - groupedResponseTask: isSet(object.groupedResponseTask) ? globalThis.String(object.groupedResponseTask) : "", - groupedProperties: globalThis.Array.isArray(object?.groupedProperties) - ? object.groupedProperties.map((e: any) => globalThis.String(e)) - : [], - }; - }, - - toJSON(message: GenerativeSearch): unknown { - const obj: any = {}; - if (message.singleResponsePrompt !== "") { - obj.singleResponsePrompt = message.singleResponsePrompt; - } - if (message.groupedResponseTask !== "") { - obj.groupedResponseTask = message.groupedResponseTask; - } - if (message.groupedProperties?.length) { - obj.groupedProperties = message.groupedProperties; - } - return obj; - }, - - create(base?: DeepPartial): GenerativeSearch { - return GenerativeSearch.fromPartial(base ?? {}); - }, - fromPartial(object: DeepPartial): GenerativeSearch { - const message = createBaseGenerativeSearch(); - message.singleResponsePrompt = object.singleResponsePrompt ?? ""; - message.groupedResponseTask = object.groupedResponseTask ?? ""; - message.groupedProperties = object.groupedProperties?.map((e) => e) || []; - return message; - }, -}; - function createBaseMetadataRequest(): MetadataRequest { return { uuid: false, @@ -1692,8 +1646,82 @@ export const ObjectPropertiesRequest = { }, }; +function createBaseWeightsForTarget(): WeightsForTarget { + return { target: "", weight: 0 }; +} + +export const WeightsForTarget = { + encode(message: WeightsForTarget, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.target !== "") { + writer.uint32(10).string(message.target); + } + if (message.weight !== 0) { + writer.uint32(21).float(message.weight); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): WeightsForTarget { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWeightsForTarget(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.target = reader.string(); + continue; + case 2: + if (tag !== 21) { + break; + } + + message.weight = reader.float(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): WeightsForTarget { + return { + target: isSet(object.target) ? globalThis.String(object.target) : "", + weight: isSet(object.weight) ? globalThis.Number(object.weight) : 0, + }; + }, + + toJSON(message: WeightsForTarget): unknown { + const obj: any = {}; + if (message.target !== "") { + obj.target = message.target; + } + if (message.weight !== 0) { + obj.weight = message.weight; + } + return obj; + }, + + create(base?: DeepPartial): WeightsForTarget { + return WeightsForTarget.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): WeightsForTarget { + const message = createBaseWeightsForTarget(); + message.target = object.target ?? ""; + message.weight = object.weight ?? 0; + return message; + }, +}; + function createBaseTargets(): Targets { - return { targetVectors: [], combination: 0, weights: {} }; + return { targetVectors: [], combination: 0, weights: {}, weightsForTargets: [] }; } export const Targets = { @@ -1707,6 +1735,9 @@ export const Targets = { Object.entries(message.weights).forEach(([key, value]) => { Targets_WeightsEntry.encode({ key: key as any, value }, writer.uint32(26).fork()).ldelim(); }); + for (const v of message.weightsForTargets) { + WeightsForTarget.encode(v!, writer.uint32(34).fork()).ldelim(); + } return writer; }, @@ -1741,6 +1772,13 @@ export const Targets = { message.weights[entry3.key] = entry3.value; } continue; + case 4: + if (tag !== 34) { + break; + } + + message.weightsForTargets.push(WeightsForTarget.decode(reader, reader.uint32())); + continue; } if ((tag & 7) === 4 || tag === 0) { break; @@ -1762,6 +1800,9 @@ export const Targets = { return acc; }, {}) : {}, + weightsForTargets: globalThis.Array.isArray(object?.weightsForTargets) + ? object.weightsForTargets.map((e: any) => WeightsForTarget.fromJSON(e)) + : [], }; }, @@ -1782,6 +1823,9 @@ export const Targets = { }); } } + if (message.weightsForTargets?.length) { + obj.weightsForTargets = message.weightsForTargets.map((e) => WeightsForTarget.toJSON(e)); + } return obj; }, @@ -1798,6 +1842,7 @@ export const Targets = { } return acc; }, {}); + message.weightsForTargets = object.weightsForTargets?.map((e) => WeightsForTarget.fromPartial(e)) || []; return message; }, }; @@ -1888,6 +1933,7 @@ function createBaseHybrid(): Hybrid { nearText: undefined, nearVector: undefined, targets: undefined, + vectorDistance: undefined, }; } @@ -1925,6 +1971,9 @@ export const Hybrid = { if (message.targets !== undefined) { Targets.encode(message.targets, writer.uint32(82).fork()).ldelim(); } + if (message.vectorDistance !== undefined) { + writer.uint32(165).float(message.vectorDistance); + } return writer; }, @@ -2015,6 +2064,13 @@ export const Hybrid = { message.targets = Targets.decode(reader, reader.uint32()); continue; + case 20: + if (tag !== 165) { + break; + } + + message.vectorDistance = reader.float(); + continue; } if ((tag & 7) === 4 || tag === 0) { break; @@ -2040,6 +2096,7 @@ export const Hybrid = { nearText: isSet(object.nearText) ? NearTextSearch.fromJSON(object.nearText) : undefined, nearVector: isSet(object.nearVector) ? NearVector.fromJSON(object.nearVector) : undefined, targets: isSet(object.targets) ? Targets.fromJSON(object.targets) : undefined, + vectorDistance: isSet(object.vectorDistance) ? globalThis.Number(object.vectorDistance) : undefined, }; }, @@ -2075,6 +2132,9 @@ export const Hybrid = { if (message.targets !== undefined) { obj.targets = Targets.toJSON(message.targets); } + if (message.vectorDistance !== undefined) { + obj.vectorDistance = message.vectorDistance; + } return obj; }, @@ -2099,6 +2159,7 @@ export const Hybrid = { message.targets = (object.targets !== undefined && object.targets !== null) ? Targets.fromPartial(object.targets) : undefined; + message.vectorDistance = object.vectorDistance ?? undefined; return message; }, }; @@ -3279,6 +3340,80 @@ export const RefPropertiesRequest = { }, }; +function createBaseVectorForTarget(): VectorForTarget { + return { name: "", vectorBytes: new Uint8Array(0) }; +} + +export const VectorForTarget = { + encode(message: VectorForTarget, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.name !== "") { + writer.uint32(10).string(message.name); + } + if (message.vectorBytes.length !== 0) { + writer.uint32(18).bytes(message.vectorBytes); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): VectorForTarget { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseVectorForTarget(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.name = reader.string(); + continue; + case 2: + if (tag !== 18) { + break; + } + + message.vectorBytes = reader.bytes(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): VectorForTarget { + return { + name: isSet(object.name) ? globalThis.String(object.name) : "", + vectorBytes: isSet(object.vectorBytes) ? bytesFromBase64(object.vectorBytes) : new Uint8Array(0), + }; + }, + + toJSON(message: VectorForTarget): unknown { + const obj: any = {}; + if (message.name !== "") { + obj.name = message.name; + } + if (message.vectorBytes.length !== 0) { + obj.vectorBytes = base64FromBytes(message.vectorBytes); + } + return obj; + }, + + create(base?: DeepPartial): VectorForTarget { + return VectorForTarget.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): VectorForTarget { + const message = createBaseVectorForTarget(); + message.name = object.name ?? ""; + message.vectorBytes = object.vectorBytes ?? new Uint8Array(0); + return message; + }, +}; + function createBaseNearVector(): NearVector { return { vector: [], @@ -3288,6 +3423,7 @@ function createBaseNearVector(): NearVector { targetVectors: [], targets: undefined, vectorPerTarget: {}, + vectorForTargets: [], }; } @@ -3316,6 +3452,9 @@ export const NearVector = { Object.entries(message.vectorPerTarget).forEach(([key, value]) => { NearVector_VectorPerTargetEntry.encode({ key: key as any, value }, writer.uint32(58).fork()).ldelim(); }); + for (const v of message.vectorForTargets) { + VectorForTarget.encode(v!, writer.uint32(66).fork()).ldelim(); + } return writer; }, @@ -3388,6 +3527,13 @@ export const NearVector = { message.vectorPerTarget[entry7.key] = entry7.value; } continue; + case 8: + if (tag !== 66) { + break; + } + + message.vectorForTargets.push(VectorForTarget.decode(reader, reader.uint32())); + continue; } if ((tag & 7) === 4 || tag === 0) { break; @@ -3413,6 +3559,9 @@ export const NearVector = { return acc; }, {}) : {}, + vectorForTargets: globalThis.Array.isArray(object?.vectorForTargets) + ? object.vectorForTargets.map((e: any) => VectorForTarget.fromJSON(e)) + : [], }; }, @@ -3445,6 +3594,9 @@ export const NearVector = { }); } } + if (message.vectorForTargets?.length) { + obj.vectorForTargets = message.vectorForTargets.map((e) => VectorForTarget.toJSON(e)); + } return obj; }, @@ -3470,6 +3622,7 @@ export const NearVector = { }, {}, ); + message.vectorForTargets = object.vectorForTargets?.map((e) => VectorForTarget.fromPartial(e)) || []; return message; }, }; @@ -3746,7 +3899,13 @@ export const Rerank = { }; function createBaseSearchReply(): SearchReply { - return { took: 0, results: [], generativeGroupedResult: undefined, groupByResults: [] }; + return { + took: 0, + results: [], + generativeGroupedResult: undefined, + groupByResults: [], + generativeGroupedResults: undefined, + }; } export const SearchReply = { @@ -3763,6 +3922,9 @@ export const SearchReply = { for (const v of message.groupByResults) { GroupByResult.encode(v!, writer.uint32(34).fork()).ldelim(); } + if (message.generativeGroupedResults !== undefined) { + GenerativeResult.encode(message.generativeGroupedResults, writer.uint32(42).fork()).ldelim(); + } return writer; }, @@ -3801,6 +3963,13 @@ export const SearchReply = { message.groupByResults.push(GroupByResult.decode(reader, reader.uint32())); continue; + case 5: + if (tag !== 42) { + break; + } + + message.generativeGroupedResults = GenerativeResult.decode(reader, reader.uint32()); + continue; } if ((tag & 7) === 4 || tag === 0) { break; @@ -3822,6 +3991,9 @@ export const SearchReply = { groupByResults: globalThis.Array.isArray(object?.groupByResults) ? object.groupByResults.map((e: any) => GroupByResult.fromJSON(e)) : [], + generativeGroupedResults: isSet(object.generativeGroupedResults) + ? GenerativeResult.fromJSON(object.generativeGroupedResults) + : undefined, }; }, @@ -3839,6 +4011,9 @@ export const SearchReply = { if (message.groupByResults?.length) { obj.groupByResults = message.groupByResults.map((e) => GroupByResult.toJSON(e)); } + if (message.generativeGroupedResults !== undefined) { + obj.generativeGroupedResults = GenerativeResult.toJSON(message.generativeGroupedResults); + } return obj; }, @@ -3851,6 +4026,10 @@ export const SearchReply = { message.results = object.results?.map((e) => SearchResult.fromPartial(e)) || []; message.generativeGroupedResult = object.generativeGroupedResult ?? undefined; message.groupByResults = object.groupByResults?.map((e) => GroupByResult.fromPartial(e)) || []; + message.generativeGroupedResults = + (object.generativeGroupedResults !== undefined && object.generativeGroupedResults !== null) + ? GenerativeResult.fromPartial(object.generativeGroupedResults) + : undefined; return message; }, }; @@ -3912,63 +4091,6 @@ export const RerankReply = { }, }; -function createBaseGenerativeReply(): GenerativeReply { - return { result: "" }; -} - -export const GenerativeReply = { - encode(message: GenerativeReply, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { - if (message.result !== "") { - writer.uint32(10).string(message.result); - } - return writer; - }, - - decode(input: _m0.Reader | Uint8Array, length?: number): GenerativeReply { - const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); - let end = length === undefined ? reader.len : reader.pos + length; - const message = createBaseGenerativeReply(); - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - if (tag !== 10) { - break; - } - - message.result = reader.string(); - continue; - } - if ((tag & 7) === 4 || tag === 0) { - break; - } - reader.skipType(tag & 7); - } - return message; - }, - - fromJSON(object: any): GenerativeReply { - return { result: isSet(object.result) ? globalThis.String(object.result) : "" }; - }, - - toJSON(message: GenerativeReply): unknown { - const obj: any = {}; - if (message.result !== "") { - obj.result = message.result; - } - return obj; - }, - - create(base?: DeepPartial): GenerativeReply { - return GenerativeReply.fromPartial(base ?? {}); - }, - fromPartial(object: DeepPartial): GenerativeReply { - const message = createBaseGenerativeReply(); - message.result = object.result ?? ""; - return message; - }, -}; - function createBaseGroupByResult(): GroupByResult { return { name: "", @@ -3978,6 +4100,7 @@ function createBaseGroupByResult(): GroupByResult { objects: [], rerank: undefined, generative: undefined, + generativeResult: undefined, }; } @@ -4004,6 +4127,9 @@ export const GroupByResult = { if (message.generative !== undefined) { GenerativeReply.encode(message.generative, writer.uint32(58).fork()).ldelim(); } + if (message.generativeResult !== undefined) { + GenerativeResult.encode(message.generativeResult, writer.uint32(66).fork()).ldelim(); + } return writer; }, @@ -4063,6 +4189,13 @@ export const GroupByResult = { message.generative = GenerativeReply.decode(reader, reader.uint32()); continue; + case 8: + if (tag !== 66) { + break; + } + + message.generativeResult = GenerativeResult.decode(reader, reader.uint32()); + continue; } if ((tag & 7) === 4 || tag === 0) { break; @@ -4083,6 +4216,7 @@ export const GroupByResult = { : [], rerank: isSet(object.rerank) ? RerankReply.fromJSON(object.rerank) : undefined, generative: isSet(object.generative) ? GenerativeReply.fromJSON(object.generative) : undefined, + generativeResult: isSet(object.generativeResult) ? GenerativeResult.fromJSON(object.generativeResult) : undefined, }; }, @@ -4109,6 +4243,9 @@ export const GroupByResult = { if (message.generative !== undefined) { obj.generative = GenerativeReply.toJSON(message.generative); } + if (message.generativeResult !== undefined) { + obj.generativeResult = GenerativeResult.toJSON(message.generativeResult); + } return obj; }, @@ -4128,12 +4265,15 @@ export const GroupByResult = { message.generative = (object.generative !== undefined && object.generative !== null) ? GenerativeReply.fromPartial(object.generative) : undefined; + message.generativeResult = (object.generativeResult !== undefined && object.generativeResult !== null) + ? GenerativeResult.fromPartial(object.generativeResult) + : undefined; return message; }, }; function createBaseSearchResult(): SearchResult { - return { properties: undefined, metadata: undefined }; + return { properties: undefined, metadata: undefined, generative: undefined }; } export const SearchResult = { @@ -4144,6 +4284,9 @@ export const SearchResult = { if (message.metadata !== undefined) { MetadataResult.encode(message.metadata, writer.uint32(18).fork()).ldelim(); } + if (message.generative !== undefined) { + GenerativeResult.encode(message.generative, writer.uint32(26).fork()).ldelim(); + } return writer; }, @@ -4168,6 +4311,13 @@ export const SearchResult = { message.metadata = MetadataResult.decode(reader, reader.uint32()); continue; + case 3: + if (tag !== 26) { + break; + } + + message.generative = GenerativeResult.decode(reader, reader.uint32()); + continue; } if ((tag & 7) === 4 || tag === 0) { break; @@ -4181,6 +4331,7 @@ export const SearchResult = { return { properties: isSet(object.properties) ? PropertiesResult.fromJSON(object.properties) : undefined, metadata: isSet(object.metadata) ? MetadataResult.fromJSON(object.metadata) : undefined, + generative: isSet(object.generative) ? GenerativeResult.fromJSON(object.generative) : undefined, }; }, @@ -4192,6 +4343,9 @@ export const SearchResult = { if (message.metadata !== undefined) { obj.metadata = MetadataResult.toJSON(message.metadata); } + if (message.generative !== undefined) { + obj.generative = GenerativeResult.toJSON(message.generative); + } return obj; }, @@ -4206,6 +4360,9 @@ export const SearchResult = { message.metadata = (object.metadata !== undefined && object.metadata !== null) ? MetadataResult.fromPartial(object.metadata) : undefined; + message.generative = (object.generative !== undefined && object.generative !== null) + ? GenerativeResult.fromPartial(object.generative) + : undefined; return message; }, }; diff --git a/src/utils/dbVersion.ts b/src/utils/dbVersion.ts index fd53ef33..b1a3e4c9 100644 --- a/src/utils/dbVersion.ts +++ b/src/utils/dbVersion.ts @@ -157,6 +157,40 @@ export class DbVersionSupport { }; }); }; + + supportsMultiVectorSearch = () => { + return this.dbVersionProvider.getVersion().then((version) => { + return { + version: version, + supports: version.isAtLeast(1, 26, 0), + message: this.errorMessage('Multi-vector search', version.show(), '1.26.0'), + }; + }); + }; + + supportsMultiVectorPerTargetSearch = () => { + return this.dbVersionProvider.getVersion().then((version) => { + return { + version: version, + supports: version.isAtLeast(1, 27, 0), + message: this.errorMessage('Multi-vector-per-target search', version.show(), '1.27.0'), + }; + }); + }; + + supportsMultiWeightsPerTargetSearch = () => { + return this.dbVersionProvider.getVersion().then((version) => { + return { + version: version, + supports: version.isAtLeast(1, 27, 0), + message: this.errorMessage( + 'Multi-target vector search with multiple weights', + version.show(), + '1.27.0' + ), + }; + }); + }; } const EMPTY_VERSION = ''; diff --git a/tools/refresh_protos.sh b/tools/refresh_protos.sh index b8857b1f..bbcb5529 100755 --- a/tools/refresh_protos.sh +++ b/tools/refresh_protos.sh @@ -31,6 +31,7 @@ sed -i '' 's/google\/protobuf\/struct"/google\/protobuf\/struct.js"/g' src/prot sed -i '' 's/\".\/base\"/\".\/base.js\"/g' src/proto/v1/*.ts sed -i '' 's/\".\/batch\"/\".\/batch.js\"/g' src/proto/v1/*.ts sed -i '' 's/\".\/batch_delete\"/\".\/batch_delete.js\"/g' src/proto/v1/*.ts +sed -i '' 's/\".\/generative\"/\".\/generative.js\"/g' src/proto/v1/*.ts sed -i '' 's/\".\/properties\"/\".\/properties.js\"/g' src/proto/v1/*.ts sed -i '' 's/\".\/search_get\"/\".\/search_get.js\"/g' src/proto/v1/*.ts sed -i '' 's/\".\/tenants\"/\".\/tenants.js\"/g' src/proto/v1/*.ts