1859

pending completion

Build # 1859

Build Type

Pull #554

travis-ci-com

Committed by

web-flow

Commit Message

Merge 0861586e2 into 66d6ca7f1

Pull Request Pull Request #554: Fix requoting bug

Run Details

11273 of 24605 branches covered (45.82%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

26589 of 46547 relevant lines covered (57.12%)

408146.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.23

/languages/thingtalk/dialogue_acts/recommendation.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of Genie
//
// Copyright 2020 The Board of Trustees of the Leland Stanford Junior University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>


import assert from 'assert';

import { Ast, } from 'thingtalk';

import * as C from '../ast_manip';
import ThingpediaLoader from '../load-thingpedia';

import { SlotBag } from '../slot_bag';
import {
    AgentReplyOptions,
    ContextInfo,
    makeAgentReply,
    makeSimpleState,
    addActionParam,
    addNewItem,
} from '../state_manip';
import {
    isInfoPhraseCompatibleWithResult,
    findChainParam
} from './common';
import {
    refineFilterToAnswerQuestionOrChangeFilter,
    combinePreambleAndRequest,
    proposalReply
} from './refinement-helpers';
import {
    addSlotToBag,
} from './results';


export interface Recommendation {
    ctx : ContextInfo;
    topResult : Ast.DialogueHistoryResultItem;
    info : SlotBag|null;
    action : Ast.Invocation|null;
    hasLearnMore : boolean;
    hasAnythingElse : boolean;
}

export function recommendationKeyFn(rec : Recommendation) {
    return {
        functionName: rec.ctx.currentFunction!.qualifiedName
    };
}

function makeActionRecommendation(ctx : ContextInfo, action : Ast.Invocation) {
    assert(action instanceof Ast.Invocation);

    const results = ctx.results;
    assert(results && results.length > 0);
    const currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;
    const last = currentTable.last;
    if (last instanceof Ast.SliceExpression && last.limit.toJS() !== 1)
        return null;

    const topResult = results[0];
    const id = topResult.value.id;
    if (!id)
        return null;

    if (action.in_params.length !== 1)
        return null;

    for (const param of action.in_params) {
        if (param.value.equals(id))
            return { ctx, topResult, info: null, action, hasLearnMore: false, hasAnythingElse: false };
    }

    return null;
}

function makeArgMinMaxRecommendation(ctx : ContextInfo, name : Ast.Value, base : Ast.Expression, param : C.ParamSlot, direction : 'asc'|'desc') {
    const resultInfo = ctx.resultInfo!;
    if (!resultInfo.argMinMaxField)
        return null;
    if (!C.isSameFunction(base.schema!, ctx.currentFunction!))
        return null;
    if (!C.isSameFunction(param.schema, ctx.currentFunction!))
        return null;
    if (direction !== resultInfo.argMinMaxField[1] ||
        param.name !== resultInfo.argMinMaxField[0])
        return null;

    return makeRecommendation(ctx, name);
}

function makeRecommendation(ctx : ContextInfo, name : Ast.Value) {
    const results = ctx.results;
    assert(results && results.length > 0);
    const currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;
    const last = currentTable.last;
    if (last instanceof Ast.SliceExpression && last.limit.toJS() !== 1)
        return null;

    const topResult = results[0];
    const id = topResult.value.id;

    if (!id || !id.equals(name))
        return null;

    return {
        ctx, topResult,
        info: null,
        action: ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null,
        hasLearnMore: false,
        hasAnythingElse: false
    };
}

function makeThingpediaRecommendation(ctx : ContextInfo, info : SlotBag) {
    const results = ctx.results;
    assert(results && results.length > 0);
    const currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;
    const last = currentTable.last;
    if (last instanceof Ast.SliceExpression && last.limit.toJS() !== 1)
        return null;

    const topResult = results[0];
    if (!isInfoPhraseCompatibleWithResult(topResult, info))
        return null;

    return {
        ctx, topResult,
        info,
        action: ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null,
        hasLearnMore: false,
        hasAnythingElse: false
    };
}

function checkRecommendation(rec : Recommendation, info : SlotBag|null) {
    if (info && !isInfoPhraseCompatibleWithResult(rec.topResult, info))
        return null;

    const resultInfo = rec.ctx.resultInfo!;
    if (resultInfo.projection !== null) {
        // check that all projected names are present
        for (const name of resultInfo.projection) {
            if (!((info && info.has(name)) || (rec.info && rec.info.has(name))))
                return null;
        }
    }

    return {
        ctx: rec.ctx, topResult: rec.topResult,
        info: info && rec.info ? SlotBag.merge(info, rec.info) : (info || rec.info),
        action: rec.action,
        hasLearnMore: rec.hasLearnMore,
        hasAnythingElse: rec.hasAnythingElse
    };
}

function checkActionForRecommendation(rec : Recommendation, action : Ast.Invocation) {
    if (!rec.topResult.value.id)
        return null;
    const resultType = rec.topResult.value.id.getType();

    if (rec.action !== null) {
        if (!C.isSameFunction(rec.action.schema!, action.schema!))
            return null;
    }

    if (!C.hasArgumentOfType(action, resultType))
        return null;

    return {
        ctx: rec.ctx, topResult: rec.topResult,
        info: rec.info,
        action,
        hasLearnMore: rec.hasLearnMore,
        hasAnythingElse: rec.hasAnythingElse
    };
}

// make a recommendation that looks like an answer, that is, "so and so is a ..."
function makeAnswerStyleRecommendation(rec : Recommendation, filter : C.FilterSlot) {
    assert(C.isSameFunction(rec.ctx.currentFunction!, filter.schema));
    const added = addSlotToBag(new SlotBag(rec.ctx.currentFunction), filter);
    if (!added)
        return null;

    return checkRecommendation(rec, added[0]);
}

export function recommendationSetLearnMore(rec : Recommendation) {
    return {
        ctx: rec.ctx, topResult: rec.topResult,
        info: rec.info,
        // reset the action to null if the agent explicitly asks to "learn more"
        action: null,
        hasLearnMore: true,
        hasAnythingElse: rec.hasAnythingElse
    };
}

function makeDisplayResult(ctx : ContextInfo, info : SlotBag) {
    const results = ctx.results;
    assert(results && results.length > 0);
    const topResult = results[0];

    if (ctx.currentFunction!.is_list)
        return null;
    if (!C.isSameFunction(ctx.currentFunction!, info.schema!))
        return null;
    if (!isInfoPhraseCompatibleWithResult(topResult, info))
        return null;
    return {
        ctx, topResult,
        info,
        action: ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null,
        hasLearnMore: false,
        hasAnythingElse: false
    };
}

function combineDisplayResult(proposal : Recommendation, newInfo : SlotBag) {
    const { ctx, info:oldInfo } = proposal;
    if (!ctx)
        return null;
    const results = ctx.results;
    assert(results && results.length > 0);
    const topResult = results[0];
    assert(isInfoPhraseCompatibleWithResult(topResult, newInfo));

    const maybeNewInfo = oldInfo ? SlotBag.merge(oldInfo, newInfo) : newInfo;
    if (maybeNewInfo === null)
        return null;

    const newProposal : Recommendation = {
        ctx: proposal.ctx,
        topResult: proposal.topResult,
        info: maybeNewInfo,
        action: proposal.action,
        hasLearnMore: false,
        hasAnythingElse: proposal.hasAnythingElse,
    };
    return newProposal;
}

function checkDisplayResult(proposal : Recommendation|null) {
    if (!proposal)
        return null;

    const resultInfo = proposal.ctx.resultInfo!;
    if (resultInfo.projection !== null) {
        // check that all projected names are present
        for (const name of resultInfo.projection) {
            if (!proposal.info || !proposal.info.has(name))
                return null;
        }
    }

    return proposal;
}

function makeRecommendationReply(ctx : ContextInfo, proposal : Recommendation) {
    const { topResult, action, hasLearnMore } = proposal;
    const options : AgentReplyOptions = {
        numResults: 1
    };
    if (action || hasLearnMore)
        options.end = false;
    if (action === null) {
        return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_recommend_one', null), proposal, null, options);
    } else {
        const chainParam = findChainParam(topResult, action);
        if (!chainParam)
            return null;
        return makeAgentReply(ctx, addActionParam(ctx, 'sys_recommend_one', action, chainParam, topResult.value.id, 'proposed'),
            proposal, null, options);
    }
}

function makeDisplayResultReply(ctx : ContextInfo, proposal : Recommendation) {
    const { action, hasAnythingElse } = proposal;
    const options : AgentReplyOptions = {
        numResults: 1
    };
    if (action || hasAnythingElse)
        options.end = false;
    return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_display_result', null), proposal, null, options);
}

function negativeRecommendationReply(ctx : ContextInfo, [preamble, request] : [Ast.Expression|null, Ast.Expression|null]) {
    if (!((preamble === null || preamble instanceof Ast.FilterExpression) &&
          (request === null || request instanceof Ast.FilterExpression)))
        return null;

    const proposal = ctx.aux;
    const { topResult, info, } = proposal;
    const proposalType = topResult.value.id ? topResult.value.id.getType() : null;
    request = combinePreambleAndRequest(preamble, request, info, proposalType);
    if (request === null)
        return null;
    return proposalReply(ctx, request, refineFilterToAnswerQuestionOrChangeFilter);
}

function positiveRecommendationReply(loader : ThingpediaLoader,
                                     ctx : ContextInfo,
                                     acceptedAction : Ast.Invocation|null,
                                     name : Ast.Value|null) {
    const proposal = ctx.aux as Recommendation;
    const { topResult, action: actionProposal } = proposal;

    // FIXME this should be allowed when we can parameter-pass by non-ID
    if (!topResult.value.id)
        return null;

    if (acceptedAction === null) {
        // if the user did not give an action earlier, and no action
        // was proposed by the agent right now, the flow is roughly
        //
        // U: hello i am looking for a restaurant
        // A: how about the ... ?
        // U: sure I like that
        //
        // this doesn't make much sense, so we don't want this flow
        if (actionProposal === null)
            return null;

        acceptedAction = actionProposal;
    }
    assert(acceptedAction);

    if (actionProposal !== null && !C.isSameFunction(actionProposal.schema!, acceptedAction.schema!))
        return null;
    if (name !== null && !topResult.value.id.equals(name))
        return null;

    // do not consider a phrase of the form "play X" to be "accepting the action by name"
    // if the action auto-confirms, because the user is likely playing something else
    if (name) {
        const confirm = loader.ttUtils.normalizeConfirmAnnotation(acceptedAction.schema as Ast.FunctionDef);
        if (confirm === 'auto')
            return null;
    }

    const chainParam = findChainParam(topResult, acceptedAction);
    if (!chainParam)
        return null;
    return addActionParam(ctx, 'execute', acceptedAction!, chainParam, topResult.value.id, 'accepted');
}

function recommendationCancelReply(ctx : ContextInfo, valid : boolean) {
    // see dialogue.genie for the meaning of this boolean
    if (!valid)
        return null;

    // "thank you" closes the dialogue
    // we cannot close the dialogue if we have pending actions
    if (ctx.next)
        return null;
    return makeSimpleState(ctx, 'cancel', null);
}

function recommendationLearnMoreReply(ctx : ContextInfo, name : Ast.Value|null) {
    const proposal = ctx.aux as Recommendation;
    const { topResult, } = proposal;
    if (name !== null && (!topResult.value.id || !topResult.value.id.equals(name)))
        return null;
    return makeSimpleState(ctx, 'learn_more', null);
}

function repeatCommandReply(ctx : ContextInfo) {
    if (ctx.next)
        return null;
    if (ctx.currentFunction!.is_monitorable)
        return null;

    const clone = ctx.current!.clone();
    clone.results = null;
    clone.confirm = 'accepted';
    return addNewItem(ctx, 'execute', null, 'accepted', clone);
}

export {
    makeActionRecommendation,
    makeArgMinMaxRecommendation,
    makeRecommendation,
    makeThingpediaRecommendation,
    makeAnswerStyleRecommendation,
    checkRecommendation,
    checkActionForRecommendation,
    makeDisplayResult,
    combineDisplayResult,
    checkDisplayResult,
    makeRecommendationReply,
    makeDisplayResultReply,

    positiveRecommendationReply,
    negativeRecommendationReply,
    recommendationCancelReply,
    recommendationLearnMoreReply,
    repeatCommandReply,
};

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of Genie
4	//
5	// Copyright 2020 The Board of Trustees of the Leland Stanford Junior University
6	//
7	// Licensed under the Apache License, Version 2.0 (the "License");
8	// you may not use this file except in compliance with the License.
9	// You may obtain a copy of the License at
10	//
11	// http://www.apache.org/licenses/LICENSE-2.0
12	//
13	// Unless required by applicable law or agreed to in writing, software
14	// distributed under the License is distributed on an "AS IS" BASIS,
15	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	// See the License for the specific language governing permissions and
17	// limitations under the License.
18	//
19	// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>
20
21
22	import assert from 'assert';	2✔
23
24	import { Ast, } from 'thingtalk';	2✔
25
26	import * as C from '../ast_manip';	2✔
27	import ThingpediaLoader from '../load-thingpedia';
28
29	import { SlotBag } from '../slot_bag';	2✔
30	import {	2✔
31	AgentReplyOptions,
32	ContextInfo,
33	makeAgentReply,
34	makeSimpleState,
35	addActionParam,
36	addNewItem,
37	} from '../state_manip';
38	import {	2✔
39	isInfoPhraseCompatibleWithResult,
40	findChainParam
41	} from './common';
42	import {	2✔
43	refineFilterToAnswerQuestionOrChangeFilter,
44	combinePreambleAndRequest,
45	proposalReply
46	} from './refinement-helpers';
47	import {	2✔
48	addSlotToBag,
49	} from './results';
50
51
52	export interface Recommendation {
53	ctx : ContextInfo;
54	topResult : Ast.DialogueHistoryResultItem;
55	info : SlotBag\|null;
56	action : Ast.Invocation\|null;
57	hasLearnMore : boolean;
58	hasAnythingElse : boolean;
59	}
60
61	export function recommendationKeyFn(rec : Recommendation) {	2✔
62	return {	12,161✔
63	functionName: rec.ctx.currentFunction!.qualifiedName
64	};
65	}
66
67	function makeActionRecommendation(ctx : ContextInfo, action : Ast.Invocation) {
68	assert(action instanceof Ast.Invocation);	35,848✔
69
70	const results = ctx.results;	35,848✔
71	assert(results && results.length > 0);	35,848✔
72	const currentStmt = ctx.current!.stmt;	35,848✔
73	const currentTable = currentStmt.expression;	35,848✔
74	const last = currentTable.last;	35,848✔
75	if (last instanceof Ast.SliceExpression && last.limit.toJS() !== 1)	35,848!
76	return null;	×
77
78	const topResult = results[0];	35,848✔
79	const id = topResult.value.id;	35,848✔
80	if (!id)	35,848✔
81	return null;	34,790✔
82
83	if (action.in_params.length !== 1)	1,058✔
84	return null;	960✔
85
86	for (const param of action.in_params) {	98✔
87	if (param.value.equals(id))	98!
88	return { ctx, topResult, info: null, action, hasLearnMore: false, hasAnythingElse: false };	×
89	}
90
91	return null;	98✔
92	}
93
94	function makeArgMinMaxRecommendation(ctx : ContextInfo, name : Ast.Value, base : Ast.Expression, param : C.ParamSlot, direction : 'asc'\|'desc') {
95	const resultInfo = ctx.resultInfo!;	99,286✔
96	if (!resultInfo.argMinMaxField)	99,286!
97	return null;	×
98	if (!C.isSameFunction(base.schema!, ctx.currentFunction!))	99,286!
99	return null;	×
100	if (!C.isSameFunction(param.schema, ctx.currentFunction!))	99,286!
101	return null;	×
102	if (direction !== resultInfo.argMinMaxField[1] \|\|	99,286✔
103	param.name !== resultInfo.argMinMaxField[0])
104	return null;	99,121✔
105
106	return makeRecommendation(ctx, name);	165✔
107	}
108
109	function makeRecommendation(ctx : ContextInfo, name : Ast.Value) {
110	const results = ctx.results;	967✔
111	assert(results && results.length > 0);	967✔
112	const currentStmt = ctx.current!.stmt;	967✔
113	const currentTable = currentStmt.expression;	967✔
114	const last = currentTable.last;	967✔
115	if (last instanceof Ast.SliceExpression && last.limit.toJS() !== 1)	967!
UNCOV 116	return null;	×
117
118	const topResult = results[0];	967✔
119	const id = topResult.value.id;	967✔
120
121	if (!id \|\| !id.equals(name))	967!
122	return null;	×
123
124	return {	967✔
125	ctx, topResult,
126	info: null,
127	action: ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null,	1,934!
128	hasLearnMore: false,
129	hasAnythingElse: false
130	};
131	}
132
133	function makeThingpediaRecommendation(ctx : ContextInfo, info : SlotBag) {
134	const results = ctx.results;	16,917✔
135	assert(results && results.length > 0);	16,917✔
136	const currentStmt = ctx.current!.stmt;	16,917✔
137	const currentTable = currentStmt.expression;	16,917✔
138	const last = currentTable.last;	16,917✔
139	if (last instanceof Ast.SliceExpression && last.limit.toJS() !== 1)	16,917!
140	return null;	×
141
142	const topResult = results[0];	16,917✔
143	if (!isInfoPhraseCompatibleWithResult(topResult, info))	16,917✔
144	return null;	16,797✔
145
146	return {	120✔
147	ctx, topResult,
148	info,
149	action: ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null,	265✔
150	hasLearnMore: false,
151	hasAnythingElse: false
152	};
153	}
154
155	function checkRecommendation(rec : Recommendation, info : SlotBag\|null) {
156	if (info && !isInfoPhraseCompatibleWithResult(rec.topResult, info))	84,335✔
157	return null;	74,839✔
158
159	const resultInfo = rec.ctx.resultInfo!;	9,496✔
160	if (resultInfo.projection !== null) {	9,496✔
161	// check that all projected names are present
162	for (const name of resultInfo.projection) {	327✔
163	if (!((info && info.has(name)) \|\| (rec.info && rec.info.has(name))))	328✔
164	return null;	17✔
165	}
166	}
167
168	return {	9,479✔
169	ctx: rec.ctx, topResult: rec.topResult,
170	info: info && rec.info ? SlotBag.merge(info, rec.info) : (info \|\| rec.info),	37,916!
171	action: rec.action,
172	hasLearnMore: rec.hasLearnMore,
173	hasAnythingElse: rec.hasAnythingElse
174	};
175	}
176
177	function checkActionForRecommendation(rec : Recommendation, action : Ast.Invocation) {
178	if (!rec.topResult.value.id)	12,214!
179	return null;	×
180	const resultType = rec.topResult.value.id.getType();	12,214✔
181
182	if (rec.action !== null) {	12,214!
183	if (!C.isSameFunction(rec.action.schema!, action.schema!))	×
184	return null;	×
185	}
186
187	if (!C.hasArgumentOfType(action, resultType))	12,214✔
188	return null;	8,669✔
189
190	return {	3,545✔
191	ctx: rec.ctx, topResult: rec.topResult,
192	info: rec.info,
193	action,
194	hasLearnMore: rec.hasLearnMore,
195	hasAnythingElse: rec.hasAnythingElse
196	};
197	}
198
199	// make a recommendation that looks like an answer, that is, "so and so is a ..."
200	function makeAnswerStyleRecommendation(rec : Recommendation, filter : C.FilterSlot) {
201	assert(C.isSameFunction(rec.ctx.currentFunction!, filter.schema));	102,183✔
202	const added = addSlotToBag(new SlotBag(rec.ctx.currentFunction), filter);	102,183✔
203	if (!added)	102,183✔
204	return null;	27,326✔
205
206	return checkRecommendation(rec, added[0]);	74,857✔
207	}
208
209	export function recommendationSetLearnMore(rec : Recommendation) {	2✔
210	return {	3,640✔
211	ctx: rec.ctx, topResult: rec.topResult,
212	info: rec.info,
213	// reset the action to null if the agent explicitly asks to "learn more"
214	action: null,
215	hasLearnMore: true,
216	hasAnythingElse: rec.hasAnythingElse
217	};
218	}
219
220	function makeDisplayResult(ctx : ContextInfo, info : SlotBag) {
221	const results = ctx.results;	10,307✔
222	assert(results && results.length > 0);	10,307✔
223	const topResult = results[0];	10,307✔
224
225	if (ctx.currentFunction!.is_list)	10,307✔
226	return null;	1,113✔
227	if (!C.isSameFunction(ctx.currentFunction!, info.schema!))	9,194!
228	return null;	×
229	if (!isInfoPhraseCompatibleWithResult(topResult, info))	9,194✔
230	return null;	9,019✔
231	return {	175✔
232	ctx, topResult,
233	info,
234	action: ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null,	360✔
235	hasLearnMore: false,
236	hasAnythingElse: false
237	};
238	}
239
240	function combineDisplayResult(proposal : Recommendation, newInfo : SlotBag) {
241	const { ctx, info:oldInfo } = proposal;	×
242	if (!ctx)	×
243	return null;	×
244	const results = ctx.results;	×
245	assert(results && results.length > 0);	×
246	const topResult = results[0];	×
247	assert(isInfoPhraseCompatibleWithResult(topResult, newInfo));	×
248
249	const maybeNewInfo = oldInfo ? SlotBag.merge(oldInfo, newInfo) : newInfo;	×
250	if (maybeNewInfo === null)	×
251	return null;	×
252
253	const newProposal : Recommendation = {	×
254	ctx: proposal.ctx,
255	topResult: proposal.topResult,
256	info: maybeNewInfo,
257	action: proposal.action,
258	hasLearnMore: false,
259	hasAnythingElse: proposal.hasAnythingElse,
260	};
261	return newProposal;	×
262	}
263
264	function checkDisplayResult(proposal : Recommendation\|null) {
265	if (!proposal)	1,396✔
266	return null;	1,221✔
267
268	const resultInfo = proposal.ctx.resultInfo!;	175✔
269	if (resultInfo.projection !== null) {	175✔
270	// check that all projected names are present
271	for (const name of resultInfo.projection) {	3✔
272	if (!proposal.info \|\| !proposal.info.has(name))	4✔
273	return null;	2✔
274	}
275	}
276
277	return proposal;	173✔
278	}
279
280	function makeRecommendationReply(ctx : ContextInfo, proposal : Recommendation) {
281	const { topResult, action, hasLearnMore } = proposal;	2,935✔
282	const options : AgentReplyOptions = {	2,935✔
283	numResults: 1
284	};
285	if (action \|\| hasLearnMore)	2,935✔
286	options.end = false;	968✔
287	if (action === null) {	2,935✔
288	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_recommend_one', null), proposal, null, options);	2,190✔
289	} else {
290	const chainParam = findChainParam(topResult, action);	745✔
291	if (!chainParam)	745!
292	return null;	×
293	return makeAgentReply(ctx, addActionParam(ctx, 'sys_recommend_one', action, chainParam, topResult.value.id, 'proposed'),	745✔
294	proposal, null, options);
295	}
296	}
297
298	function makeDisplayResultReply(ctx : ContextInfo, proposal : Recommendation) {
299	const { action, hasAnythingElse } = proposal;	71✔
300	const options : AgentReplyOptions = {	71✔
301	numResults: 1
302	};
303	if (action \|\| hasAnythingElse)	71!
304	options.end = false;	×
305	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_display_result', null), proposal, null, options);	71✔
306	}
307
308	function negativeRecommendationReply(ctx : ContextInfo, [preamble, request] : [Ast.Expression\|null, Ast.Expression\|null]) {
309	if (!((preamble === null \|\| preamble instanceof Ast.FilterExpression) &&	48,521!
310	(request === null \|\| request instanceof Ast.FilterExpression)))
311	return null;	×
312
313	const proposal = ctx.aux;	48,521✔
314	const { topResult, info, } = proposal;	48,521✔
315	const proposalType = topResult.value.id ? topResult.value.id.getType() : null;	48,521!
316	request = combinePreambleAndRequest(preamble, request, info, proposalType);	48,521✔
317	if (request === null)	48,521✔
318	return null;	38,661✔
319	return proposalReply(ctx, request, refineFilterToAnswerQuestionOrChangeFilter);	9,860✔
320	}
321
322	function positiveRecommendationReply(loader : ThingpediaLoader,
323	ctx : ContextInfo,
324	acceptedAction : Ast.Invocation\|null,
325	name : Ast.Value\|null) {
326	const proposal = ctx.aux as Recommendation;	283,936✔
327	const { topResult, action: actionProposal } = proposal;	283,936✔
328
329	// FIXME this should be allowed when we can parameter-pass by non-ID
330	if (!topResult.value.id)	283,936!
331	return null;	×
332
333	if (acceptedAction === null) {	283,936✔
334	// if the user did not give an action earlier, and no action
335	// was proposed by the agent right now, the flow is roughly
336	//
337	// U: hello i am looking for a restaurant
338	// A: how about the ... ?
339	// U: sure I like that
340	//
341	// this doesn't make much sense, so we don't want this flow
342	if (actionProposal === null)	278,779✔
343	return null;	187,695✔
344
345	acceptedAction = actionProposal;	91,084✔
346	}
347	assert(acceptedAction);	96,241✔
348
349	if (actionProposal !== null && !C.isSameFunction(actionProposal.schema!, acceptedAction.schema!))	96,241!
350	return null;	×
351	if (name !== null && !topResult.value.id.equals(name))	96,241✔
352	return null;	91,790✔
353
354	// do not consider a phrase of the form "play X" to be "accepting the action by name"
355	// if the action auto-confirms, because the user is likely playing something else
356	if (name) {	4,451✔
357	const confirm = loader.ttUtils.normalizeConfirmAnnotation(acceptedAction.schema as Ast.FunctionDef);	298✔
358	if (confirm === 'auto')	298!
359	return null;	298✔
360	}
361
362	const chainParam = findChainParam(topResult, acceptedAction);	4,153✔
363	if (!chainParam)	4,153✔
364	return null;	1,608✔
365	return addActionParam(ctx, 'execute', acceptedAction!, chainParam, topResult.value.id, 'accepted');	2,545✔
366	}
367
368	function recommendationCancelReply(ctx : ContextInfo, valid : boolean) {
369	// see dialogue.genie for the meaning of this boolean
370	if (!valid)	3,915✔
371	return null;	1,420✔
372
373	// "thank you" closes the dialogue
374	// we cannot close the dialogue if we have pending actions
375	if (ctx.next)	2,495✔
376	return null;	148✔
377	return makeSimpleState(ctx, 'cancel', null);	2,347✔
378	}
379
380	function recommendationLearnMoreReply(ctx : ContextInfo, name : Ast.Value\|null) {
381	const proposal = ctx.aux as Recommendation;	244,653✔
382	const { topResult, } = proposal;	244,653✔
383	if (name !== null && (!topResult.value.id \|\| !topResult.value.id.equals(name)))	244,653✔
384	return null;	241,099✔
385	return makeSimpleState(ctx, 'learn_more', null);	3,554✔
386	}
387
388	function repeatCommandReply(ctx : ContextInfo) {
389	if (ctx.next)	165!
390	return null;	×
391	if (ctx.currentFunction!.is_monitorable)	165!
392	return null;	165✔
393
394	const clone = ctx.current!.clone();	×
395	clone.results = null;	×
396	clone.confirm = 'accepted';	×
397	return addNewItem(ctx, 'execute', null, 'accepted', clone);	×
398	}
399
400	export {
401	makeActionRecommendation,	2✔
402	makeArgMinMaxRecommendation,	2✔
403	makeRecommendation,	2✔
404	makeThingpediaRecommendation,	2✔
405	makeAnswerStyleRecommendation,	2✔
406	checkRecommendation,	2✔
407	checkActionForRecommendation,	2✔
408	makeDisplayResult,	2✔
409	combineDisplayResult,	2✔
410	checkDisplayResult,	2✔
411	makeRecommendationReply,	2✔
412	makeDisplayResultReply,	2✔
413
414	positiveRecommendationReply,	2✔
415	negativeRecommendationReply,	2✔
416	recommendationCancelReply,	2✔
417	recommendationLearnMoreReply,	2✔
418	repeatCommandReply,	2✔
419	};

stanford-oval / genie-toolkit / 1859

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous