1911

pending completion

Build # 1911

Build Type

Pull #564

travis-ci-com

Committed by

web-flow

Commit Message

Merge 1d3c393d1 into fb8b240ba

Pull Request Pull Request #564: Changes to enable Genie for COVID

Run Details

12047 of 25586 branches covered (47.08%)

Branch coverage included in aggregate %.

28 of 60 new or added lines in 7 files covered. (46.67%)

28 existing lines in 4 files now uncovered.

28236 of 48264 relevant lines covered (58.5%)

380015.7 hits per line

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

75.92

/lib/dialogue-agent/conversation.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 path from "path";
import fs from "fs";
import * as events from 'events';
import type * as Tp from 'thingpedia';
import * as ThingTalk from 'thingtalk';

import * as I18n from '../i18n';

import { PlatformData } from './user-input';
import ValueCategory from './value-category';
import DialogueLoop from './dialogue-loop';
import { MessageType, Message, RDL } from './protocol';
import { EntityMap } from '../utils/entity-utils';
import * as ThingTalkUtils from '../utils/thingtalk';
import type Engine from '../engine';
import * as StreamUtils from "../utils/stream-utils";
import { DialogueSerializer, DialogueTurn } from "../dataset-tools/parsers";

const DummyStatistics = {
    hit() {
    }
};

const DEFAULT_CONVERSATION_TTL = 600000; // 10 minutes

export interface AssistantUser {
    id : string;
    account : string;
}

export interface ConversationOptions {
    nluServerUrl ?: string;
    nlgServerUrl ?: string;
    anonymous ?: boolean;
    debug ?: boolean;
    rng ?: () => number;
    inactivityTimeout ?: number;
    contextResetTimeout ?: number;
    showWelcome ?: boolean;
    deleteWhenInactive ?: boolean;
    log ?: boolean;
}

interface Statistics {
    hit(key : string) : void;
}

interface Context {
    code : string[];
    entities : EntityMap;
}

export interface ConversationDelegate {
    setHypothesis(hyp : string) : void;
    setExpected(expect : string|null, ctx : Context) : void;
    addMessage(msg : Message) : Promise<void>;
}

export class DialogueTurnLog {
    private readonly _turn : DialogueTurn;
    private _done : boolean;

    constructor() {
        this._turn = {
            context: null,
            agent: null,
            agent_target: null,
            intermediate_context: null,
            user: '',
            user_target: ''
        };
        this._done = false;
    }

    get turn() {
        return this._turn;
    }

    get done() {
        return this._done;
    }

    finish() {
        this._done = true;
    }

    update(field : Exclude<keyof DialogueTurn,'agent_timestamp'|'user_timestamp'>, value : string) {
        this._turn[field] = this._turn[field] ? this._turn[field] + '\n' + value : value;
        if (field === 'user')
            this._turn.user_timestamp = new Date;
        else if (field === 'agent')
            this._turn.agent_timestamp = new Date;
    }
}

class DialogueLog {
    private readonly _turns : DialogueTurnLog[];
    private _done : boolean;

    constructor() {
        this._turns = [];
        this._done = false;
    }

    get turns() {
        return this._turns;
    }

    get done() {
        return this._done;
    }

    finish() {
        this._done = true;
        if (this.turns.length) {
            const lastTurn = this.turns[this.turns.length - 1];
            lastTurn.finish();
        }
    }

    append(turn : DialogueTurnLog) {
        this._turns.push(turn);
    }
}

export interface ConversationState {
    history : Message[],
    dialogueState : string,
    expected : string|null
}

/**
 * A single session of conversation in Genie.
 *
 * This object is responsible for maintaining the history of the conversation
 * to support clients reconnecting to the same conversation later, as well
 * as tracking connected clients and inactivity timeouts.
 *
 * The actual conversation logic is in {@link DialogueLoop}.
 */
export default class Conversation extends events.EventEmitter {
    private _engine : Engine;
    private _user : AssistantUser;
    private _conversationId : string;
    private _locale : string;
    _ : (x : string) => string;

    private _stats : Statistics;
    private _options : ConversationOptions;
    private _debug : boolean;
    rng : () => number;

    private _loop : DialogueLoop;
    private _expecting : ValueCategory|null;
    private _context : Context;

    private _delegates : Set<ConversationDelegate>;
    private _history : Message[];
    private _nextMsgId : number;
    private _inactivityTimeout : NodeJS.Timeout|null;
    private _inactivityTimeoutSec : number;
    private _contextResetTimeout : NodeJS.Timeout|null;
    private _contextResetTimeoutSec : number;

    private _log : DialogueLog[];

    constructor(engine : Engine,
                conversationId : string,
                user : AssistantUser,
                options : ConversationOptions = {}) {
        super();
        this._engine = engine;
        this._user = user;

        this._conversationId = conversationId;
        this._locale = this._engine.platform.locale;
        this._ = I18n.get(this._locale).gettext;

        const stats = this._engine.platform.getCapability('statistics');
        if (stats === null)
            this._stats = DummyStatistics;
        else
            this._stats = stats;

        this._options = options;
        this._debug = !!this._options.debug;

        this.rng = options.rng || Math.random;

        this._loop = new DialogueLoop(this, this._engine, {
            nluServerUrl: options.nluServerUrl,
            nlgServerUrl: options.nlgServerUrl,
            debug: this._debug
        });
        this._expecting = null;
        this._context = { code: ['null'], entities: {} };
        this._delegates = new Set;
        this._history = [];
        this._nextMsgId = 0;

        this._inactivityTimeout = null;
        this._inactivityTimeoutSec = options.inactivityTimeout || DEFAULT_CONVERSATION_TTL;
        this._contextResetTimeout = null;
        this._contextResetTimeoutSec = options.contextResetTimeout || this._inactivityTimeoutSec;

        this._log = [];
    }

    get isAnonymous() : boolean {
        return !!this._options.anonymous;
    }

    get id() : string {
        return this._conversationId;
    }

    get user() : AssistantUser {
        return this._user;
    }

    get platform() : Tp.BasePlatform {
        return this._engine.platform;
    }

    get locale() : string {
        return this._engine.platform.locale;
    }

    get timezone() : string {
        return this._engine.platform.timezone;
    }

    get engine() : Engine {
        return this._engine;
    }

    get stats() : Statistics {
        return this._stats;
    }

    get schemas() : ThingTalk.SchemaRetriever {
        return this._engine.schemas;
    }

    get thingpedia() : Tp.BaseClient {
        return this._engine.thingpedia;
    }

    get history() : Message[] {
        return this._history;
    }

    get inRecordingMode() : boolean {
        return !!this._options.log;
    }

    startRecording() {
        this._options.log = true;
    }

    endRecording() {
        this._options.log = false;
        this.dialogueFinished();
    }

    notify(appId : string, outputType : string, outputValue : Record<string, unknown>) {
        return this._loop.dispatchNotify(appId, outputType, outputValue);
    }

    notifyError(appId : string, error : Error) {
        return this._loop.dispatchNotifyError(appId, error);
    }

    setExpected(expecting : ValueCategory|null, context : Context) : void {
        this._expecting = expecting;
        this._context = context;
    }

    async start(state ?: ConversationState) : Promise<void> {
        this._resetInactivityTimeout();
        if (state) {
            for (const msg of state.history)
                await this.addMessage(msg);
        }
        return this._loop.start(!!this._options.showWelcome,
            state ? state.dialogueState : null,
            state ? ValueCategory.fromString(state.expected) : null);
    }

    async stop() : Promise<void> {
        return this._loop.stop();
    }

    private _resetInactivityTimeout() {
        // after "options.inactivityTimeout" milliseconds we inform the app that the conversation
        // is inactive (turn off LEDs, close the microphone, etc.)
        if (this._inactivityTimeout)
            clearTimeout(this._inactivityTimeout);
        if (this._inactivityTimeoutSec > 0) {
            this._inactivityTimeout = setTimeout(() => {
                this.emit('inactive');
            }, this._inactivityTimeoutSec);
        }

        // after "options.contextResetTimeout", we reset the context, forgetting the state of the
        // conversation
        if (this._contextResetTimeout)
            clearTimeout(this._contextResetTimeout);
        if (this._contextResetTimeoutSec) {
            this._contextResetTimeout = setTimeout(() => {
                this._loop.reset();
            }, this._contextResetTimeoutSec);
        }
    }

    async addOutput(out : ConversationDelegate, replayHistory = true) {
        this._delegates.add(out);
        if (replayHistory) {
            for (const msg of this._history) {
                try {
                    await out.addMessage(msg);
                } catch(e) {
                    // delegate disappeared immediately (race condition)
                    this._delegates.delete(out);
                    return;
                }
            }
        }
    }
    async removeOutput(out : ConversationDelegate) {
        this._delegates.delete(out);
    }

    private _callDelegates(fn : (out : ConversationDelegate) => unknown) {
        return Promise.all(Array.from(this._delegates).map(async (out) => {
            try {
                await fn(out);
            } catch(e) {
                // delegate disappeared (likely a disconnected websocket)
                this._delegates.delete(out);
            }
        }));
    }

    async setHypothesis(hypothesis : string) : Promise<void> {
        await this._callDelegates((out) => out.setHypothesis(hypothesis));
    }

    async sendAskSpecial() : Promise<void> {
        const what = ValueCategory.toString(this._expecting);

        if (this._debug) {
            if (what !== null && what !== 'generic')
                console.log('Genie sends a special request');
            else if (what !== null)
                console.log('Genie expects an answer');
        }

        await this._callDelegates((out) => out.setExpected(what, this._context));
    }

    /**
     * Add a message to the conversation history.
     *
     * This method is exported to inject conversation history from outside.
     */
    async addMessage(msg : Message) {
        if (msg.id !== undefined)
            this._nextMsgId = Math.max(this._nextMsgId, msg.id+1);
        else
            msg.id = this._nextMsgId ++;
        this._history.push(msg);
        if (this._history.length > 30)
            this._history.shift();
        await this._callDelegates((out) => out.addMessage(msg));
    }

    /**
     * Extract the state from the conversation.
     *
     * This method is provided to save and restore the conversation state,
     * and transfer the conversation state between engines.
     */
    getState() : ConversationState {
        return {
            history: this._history.slice(),
            dialogueState: this._loop.getState(),
            expected: ValueCategory.toString(this._expecting)
        };
    }

    async handleCommand(command : string, platformData : PlatformData = {}) : Promise<void> {
        // if the command is just whitespace, ignore it without even adding it to the history
        if (!command.trim())
            return;

        this.stats.hit('sabrina-command');
        this.emit('active');
        this._resetInactivityTimeout();
        await this.addMessage({ type: MessageType.COMMAND, command });
        if (this._debug)
            console.log('Received assistant command ' + command);

        await this._loop.handleCommand({ type: 'command', utterance: command, platformData });
    }

    async handleParsedCommand(root : any, title ?: string, platformData : PlatformData = {}) : Promise<void> {
        const command = `\\r ${typeof root === 'string' ? root : JSON.stringify(root)}`;
        this.stats.hit('sabrina-parsed-command');
        this.emit('active');
        this._resetInactivityTimeout();
        if (typeof root === 'string')
            root = JSON.parse(root);
        await this.addMessage({ type: MessageType.COMMAND, command: title || command, json: root });

        if (this._debug)
            console.log('Received pre-parsed assistant command');
        if (root.example_id) {
            this.thingpedia.clickExample(root.example_id).catch((e) => {
                console.error('Failed to record example click: ' + e.message);
            });
        }

        if ('program' in root)
            return this.handleThingTalk(root.program, platformData);

        const { code, entities } = root;
        for (const name in entities) {
            if (name.startsWith('SLOT_')) {
                const slotname = root.slots![parseInt(name.substring('SLOT_'.length))];
                const slotType = ThingTalk.Type.fromString(root.slotTypes![slotname]);
                const value = ThingTalk.Ast.Value.fromJSON(slotType, entities[name]);
                entities[name] = value;
            }
        }

        const parsed = await ThingTalkUtils.parsePrediction(code, entities, {
            thingpediaClient: this._engine.thingpedia,
            schemaRetriever: this._engine.schemas,
            loadMetadata: true
        }, true);
        return this._loop.handleCommand({ type: 'thingtalk', parsed, platformData });
    }

    async handleThingTalk(program : string, platformData : PlatformData = {}) : Promise<void> {
        const command = `\\t ${program}`;
        this.stats.hit('sabrina-thingtalk-command');
        this.emit('active');
        this._resetInactivityTimeout();
        await this.addMessage({ type: MessageType.COMMAND, command });
        if (this._debug)
            console.log('Received ThingTalk program');

        const parsed = await ThingTalkUtils.parse(program, {
            thingpediaClient: this._engine.thingpedia,
            schemaRetriever: this._engine.schemas,
            loadMetadata: true
        });
        return this._loop.handleCommand({ type: 'thingtalk', parsed, platformData });
    }

    sendReply(message : string, icon : string|null) {
        if (this._debug)
            console.log('Genie says: ' + message);
        return this.addMessage({ type: MessageType.TEXT, text: message, icon });
    }

    sendMedia(mediaType : 'picture'|'audio'|'video', url : string, alt : string|undefined, icon : string|null) {
        if (this._debug)
            console.log('Genie sends ' + mediaType + ': '+ url);
        return this.addMessage({ type: mediaType as MessageType.AUDIO|MessageType.VIDEO|MessageType.PICTURE, url, alt, icon });
    }

    sendRDL(rdl : RDL, icon : string|null) {
        if (this._debug)
            console.log('Genie sends RDL: '+ rdl.callback);
        return this.addMessage({ type: MessageType.RDL, rdl, icon });
    }

    sendSoundEffect(name : string, exclusive : boolean, icon : string|null) {
        if (this._debug)
            console.log('Genie sends sound effect: '+ name);
        return this.addMessage({ type: MessageType.SOUND_EFFECT, name, exclusive, icon });
    }

    sendChoice(idx : number, title : string) {
        if (this._expecting !== ValueCategory.MultipleChoice)
            console.log('UNEXPECTED: sendChoice while not expecting a MultipleChoice');
        if (this._debug)
            console.log('Genie sends multiple choice button: '+ title);
        return this.addMessage({ type: MessageType.CHOICE, idx, title });
    }

    sendButton(title : string, json : string) {
        if (this._debug)
            console.log('Genie sends generic button: '+ title);
        return this.addMessage({ type: MessageType.BUTTON, json, title });
    }

    sendLink(title : string, url : string) {
        if (this._debug)
            console.log('Genie sends link: '+ url);
        return this.addMessage({ type: MessageType.LINK, url, title, state: this.getState() });
    }

    sendNewProgram(program : {
        uniqueId : string;
        name : string;
        code : string;
        results : Array<Record<string, unknown>>;
        errors : string[];
        icon : string|null;
    }) {
        if (this._debug)
            console.log('Genie executed new program: '+ program.uniqueId);
        return this.addMessage({ type: MessageType.NEW_PROGRAM, ...program });
    }

    private get _lastDialogue() {
        if (this._log.length === 0)
            return null;
        return this._log[this._log.length - 1];
    }

    private get _lastTurn() {
        const lastDialogue = this._lastDialogue;
        if (!lastDialogue || lastDialogue.turns.length === 0)
            return null;
        return lastDialogue.turns[lastDialogue.turns.length - 1];
    }

    appendNewDialogue() {
        this._log.push(new DialogueLog());
    }

    dialogueFinished() {
        const last = this._lastDialogue;
        if (last)
            last.finish();
    }

    turnFinished() {
        const last = this._lastTurn;
        if (last)
            last.finish();
    }

    appendNewTurn(turn : DialogueTurnLog) {
        const last = this._lastDialogue;
        if (!last || last.done)
            this.appendNewDialogue();
        const dialogue = this._lastDialogue!;
        dialogue.append(turn);
    }

    voteLast(vote : 'up'|'down') {
        const last = this._lastTurn;
        if (!last)
            throw new Error('No dialogue is logged');
        last.turn.vote = vote;
    }

    commentLast(comment : string) {
        const last = this._lastTurn;
        if (!last)
            throw new Error('No dialogue is logged');
        last.turn.comment = comment;
    }

    updateLog(field : Exclude<keyof DialogueTurn,'agent_timestamp'|'user_timestamp'>, value : string) {
        if (this.inRecordingMode) {
            let last = this._lastTurn;
            if (!last || last.done) {
                last = new DialogueTurnLog();
                this.appendNewTurn(last);
            }
            last.update(field, value);
        }
    }

    async saveLog() {
        const dir = path.join(this._engine.platform.getWritableDir(), 'logs');
        try {
            fs.mkdirSync(dir);
        } catch(e) {
            if (e.code !== 'EEXIST')
                throw e;
        }
        const logfile = path.join(dir, this.id + '.txt');
        const serializer = new DialogueSerializer({ annotations: true });

        const output = fs.createWriteStream(logfile);

        serializer.pipe(output);
        for (const dialogue of this._log)
            serializer.write({ id: this.id, turns: dialogue.turns.map((log) => log.turn) });
        serializer.end();

        await StreamUtils.waitFinish(output);
    }

    get log() : string|null {
        const log = path.join(this._engine.platform.getWritableDir(), 'logs', this.id + '.txt');
        if (!fs.existsSync(log))
            return null;
        return log;
    }
}

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 path from "path";	97✔
23	import fs from "fs";	97✔
24	import * as events from 'events';	97✔
25	import type * as Tp from 'thingpedia';
26	import * as ThingTalk from 'thingtalk';	97✔
27
28	import * as I18n from '../i18n';	97✔
29
30	import { PlatformData } from './user-input';
31	import ValueCategory from './value-category';	97✔
32	import DialogueLoop from './dialogue-loop';	97✔
33	import { MessageType, Message, RDL } from './protocol';	97✔
34	import { EntityMap } from '../utils/entity-utils';
35	import * as ThingTalkUtils from '../utils/thingtalk';	97✔
36	import type Engine from '../engine';
37	import * as StreamUtils from "../utils/stream-utils";	97✔
38	import { DialogueSerializer, DialogueTurn } from "../dataset-tools/parsers";	97✔
39
40	const DummyStatistics = {	97✔
41	hit() {
42	}
43	};
44
45	const DEFAULT_CONVERSATION_TTL = 600000; // 10 minutes	97✔
46
47	export interface AssistantUser {
48	id : string;
49	account : string;
50	}
51
52	export interface ConversationOptions {
53	nluServerUrl ?: string;
54	nlgServerUrl ?: string;
55	anonymous ?: boolean;
56	debug ?: boolean;
57	rng ?: () => number;
58	inactivityTimeout ?: number;
59	contextResetTimeout ?: number;
60	showWelcome ?: boolean;
61	deleteWhenInactive ?: boolean;
62	log ?: boolean;
63	}
64
65	interface Statistics {
66	hit(key : string) : void;
67	}
68
69	interface Context {
70	code : string[];
71	entities : EntityMap;
72	}
73
74	export interface ConversationDelegate {
75	setHypothesis(hyp : string) : void;
76	setExpected(expect : string\|null, ctx : Context) : void;
77	addMessage(msg : Message) : Promise<void>;
78	}
79
80	export class DialogueTurnLog {	97✔
81	private readonly _turn : DialogueTurn;
82	private _done : boolean;
83
84	constructor() {
85	this._turn = {	189✔
86	context: null,
87	agent: null,
88	agent_target: null,
89	intermediate_context: null,
90	user: '',
91	user_target: ''
92	};
93	this._done = false;	189✔
94	}
95
96	get turn() {
97	return this._turn;	317✔
98	}
99
100	get done() {
101	return this._done;	616✔
102	}
103
104	finish() {
105	this._done = true;	253✔
106	}
107
108	update(field : Exclude<keyof DialogueTurn,'agent_timestamp'\|'user_timestamp'>, value : string) {
109	this._turn[field] = this._turn[field] ? this._turn[field] + '\n' + value : value;	617✔
110	if (field === 'user')	617✔
111	this._turn.user_timestamp = new Date;	163✔
112	else if (field === 'agent')	454✔
113	this._turn.agent_timestamp = new Date;	104✔
114	}
115	}
116
117	class DialogueLog {
118	private readonly _turns : DialogueTurnLog[];
119	private _done : boolean;
120
121	constructor() {
122	this._turns = [];	89✔
123	this._done = false;	89✔
124	}
125
126	get turns() {
127	return this._turns;	3,080✔
128	}
129
130	get done() {
131	return this._done;	188✔
132	}
133
134	finish() {
135	this._done = true;	90✔
136	if (this.turns.length) {	90!
137	const lastTurn = this.turns[this.turns.length - 1];	90✔
138	lastTurn.finish();	90✔
139	}
140	}
141
142	append(turn : DialogueTurnLog) {
143	this._turns.push(turn);	189✔
144	}
145	}
146
147	export interface ConversationState {
148	history : Message[],
149	dialogueState : string,
150	expected : string\|null
151	}
152
153	/**
154	* A single session of conversation in Genie.
155	*
156	* This object is responsible for maintaining the history of the conversation
157	* to support clients reconnecting to the same conversation later, as well
158	* as tracking connected clients and inactivity timeouts.
159	*
160	* The actual conversation logic is in {@link DialogueLoop}.
161	*/
162	export default class Conversation extends events.EventEmitter {	97✔
163	private _engine : Engine;
164	private _user : AssistantUser;
165	private _conversationId : string;
166	private _locale : string;
167	_ : (x : string) => string;
168
169	private _stats : Statistics;
170	private _options : ConversationOptions;
171	private _debug : boolean;
172	rng : () => number;
173
174	private _loop : DialogueLoop;
175	private _expecting : ValueCategory\|null;
176	private _context : Context;
177
178	private _delegates : Set<ConversationDelegate>;
179	private _history : Message[];
180	private _nextMsgId : number;
181	private _inactivityTimeout : NodeJS.Timeout\|null;
182	private _inactivityTimeoutSec : number;
183	private _contextResetTimeout : NodeJS.Timeout\|null;
184	private _contextResetTimeoutSec : number;
185
186	private _log : DialogueLog[];
187
188	constructor(engine : Engine,
189	conversationId : string,
190	user : AssistantUser,
191	options : ConversationOptions = {}) {	×
192	super();	4✔
193	this._engine = engine;	4✔
194	this._user = user;	4✔
195
196	this._conversationId = conversationId;	4✔
197	this._locale = this._engine.platform.locale;	4✔
198	this._ = I18n.get(this._locale).gettext;	4✔
199
200	const stats = this._engine.platform.getCapability('statistics');	4✔
201	if (stats === null)	4!
202	this._stats = DummyStatistics;	4✔
203	else
204	this._stats = stats;	×
205
206	this._options = options;	4✔
207	this._debug = !!this._options.debug;	4✔
208
209	this.rng = options.rng \|\| Math.random;	4✔
210
211	this._loop = new DialogueLoop(this, this._engine, {	4✔
212	nluServerUrl: options.nluServerUrl,
213	nlgServerUrl: options.nlgServerUrl,
214	debug: this._debug
215	});
216	this._expecting = null;	4✔
217	this._context = { code: ['null'], entities: {} };	4✔
218	this._delegates = new Set;	4✔
219	this._history = [];	4✔
220	this._nextMsgId = 0;	4✔
221
222	this._inactivityTimeout = null;	4✔
223	this._inactivityTimeoutSec = options.inactivityTimeout \|\| DEFAULT_CONVERSATION_TTL;	4✔
224	this._contextResetTimeout = null;	4✔
225	this._contextResetTimeoutSec = options.contextResetTimeout \|\| this._inactivityTimeoutSec;	4✔
226
227	this._log = [];	4✔
228	}
229
230	get isAnonymous() : boolean {
231	return !!this._options.anonymous;	84✔
232	}
233
234	get id() : string {
235	return this._conversationId;	91✔
236	}
237
238	get user() : AssistantUser {
239	return this._user;	×
240	}
241
242	get platform() : Tp.BasePlatform {
243	return this._engine.platform;	×
244	}
245
246	get locale() : string {
247	return this._engine.platform.locale;	8✔
248	}
249
250	get timezone() : string {
251	return this._engine.platform.timezone;	×
252	}
253
254	get engine() : Engine {
255	return this._engine;	×
256	}
257
258	get stats() : Statistics {
259	return this._stats;	169✔
260	}
261
262	get schemas() : ThingTalk.SchemaRetriever {
263	return this._engine.schemas;	4✔
264	}
265
266	get thingpedia() : Tp.BaseClient {
267	return this._engine.thingpedia;	4✔
268	}
269
270	get history() : Message[] {
271	return this._history;	×
272	}
273
274	get inRecordingMode() : boolean {
275	return !!this._options.log;	627✔
276	}
277
278	startRecording() {
279	this._options.log = true;	1✔
280	}
281
282	endRecording() {
283	this._options.log = false;	1✔
284	this.dialogueFinished();	1✔
285	}
286
287	notify(appId : string, outputType : string, outputValue : Record<string, unknown>) {
288	return this._loop.dispatchNotify(appId, outputType, outputValue);	25✔
289	}
290
291	notifyError(appId : string, error : Error) {
292	return this._loop.dispatchNotifyError(appId, error);	3✔
293	}
294
295	setExpected(expecting : ValueCategory\|null, context : Context) : void {
296	this._expecting = expecting;	311✔
297	this._context = context;	311✔
298	}
299
300	async start(state ?: ConversationState) : Promise<void> {
301	this._resetInactivityTimeout();	3✔
302	if (state) {	3!
NEW 303	for (const msg of state.history)	×
NEW 304	await this.addMessage(msg);	×
305	}
306	return this._loop.start(!!this._options.showWelcome,	3✔
307	state ? state.dialogueState : null,	3!
308	state ? ValueCategory.fromString(state.expected) : null);	3!
309	}
310
311	async stop() : Promise<void> {
312	return this._loop.stop();	×
313	}
314
315	private _resetInactivityTimeout() {
316	// after "options.inactivityTimeout" milliseconds we inform the app that the conversation
317	// is inactive (turn off LEDs, close the microphone, etc.)
318	if (this._inactivityTimeout)	171✔
319	clearTimeout(this._inactivityTimeout);	168✔
320	if (this._inactivityTimeoutSec > 0) {	171!
321	this._inactivityTimeout = setTimeout(() => {	171✔
322	this.emit('inactive');	×
323	}, this._inactivityTimeoutSec);
324	}
325
326	// after "options.contextResetTimeout", we reset the context, forgetting the state of the
327	// conversation
328	if (this._contextResetTimeout)	171✔
329	clearTimeout(this._contextResetTimeout);	168✔
330	if (this._contextResetTimeoutSec) {	171!
331	this._contextResetTimeout = setTimeout(() => {	171✔
332	this._loop.reset();	×
333	}, this._contextResetTimeoutSec);
334	}
335	}
336
337	async addOutput(out : ConversationDelegate, replayHistory = true) {	3✔
338	this._delegates.add(out);	3✔
339	if (replayHistory) {	3!
340	for (const msg of this._history) {	3✔
341	try {	×
342	await out.addMessage(msg);	×
343	} catch(e) {
344	// delegate disappeared immediately (race condition)
345	this._delegates.delete(out);	×
346	return;	×
347	}
348	}
349	}
350	}
351	async removeOutput(out : ConversationDelegate) {
352	this._delegates.delete(out);	×
353	}
354
355	private _callDelegates(fn : (out : ConversationDelegate) => unknown) {
356	return Promise.all(Array.from(this._delegates).map(async (out) => {	538✔
357	try {	536✔
358	await fn(out);	536✔
359	} catch(e) {
360	// delegate disappeared (likely a disconnected websocket)
361	this._delegates.delete(out);	×
362	}
363	}));
364	}
365
366	async setHypothesis(hypothesis : string) : Promise<void> {
367	await this._callDelegates((out) => out.setHypothesis(hypothesis));	×
368	}
369
370	async sendAskSpecial() : Promise<void> {
371	const what = ValueCategory.toString(this._expecting);	171✔
372
373	if (this._debug) {	171!
374	if (what !== null && what !== 'generic')	171✔
375	console.log('Genie sends a special request');	30✔
376	else if (what !== null)	141!
377	console.log('Genie expects an answer');	×
378	}
379
380	await this._callDelegates((out) => out.setExpected(what, this._context));	171✔
381	}
382
383	/**
384	* Add a message to the conversation history.
385	*
386	* This method is exported to inject conversation history from outside.
387	*/
388	async addMessage(msg : Message) {
389	if (msg.id !== undefined)	367!
NEW 390	this._nextMsgId = Math.max(this._nextMsgId, msg.id+1);	×
391	else
392	msg.id = this._nextMsgId ++;	367✔
393	this._history.push(msg);	367✔
394	if (this._history.length > 30)	367✔
395	this._history.shift();	331✔
396	await this._callDelegates((out) => out.addMessage(msg));	367✔
397	}
398
399	/**
400	* Extract the state from the conversation.
401	*
402	* This method is provided to save and restore the conversation state,
403	* and transfer the conversation state between engines.
404	*/
405	getState() : ConversationState {
406	return {	4✔
407	history: this._history.slice(),
408	dialogueState: this._loop.getState(),
409	expected: ValueCategory.toString(this._expecting)
410	};
411	}
412
413	async handleCommand(command : string, platformData : PlatformData = {}) : Promise<void> {	3✔
414	// if the command is just whitespace, ignore it without even adding it to the history
415	if (!command.trim())	3!
416	return;	×
417
418	this.stats.hit('sabrina-command');	3✔
419	this.emit('active');	3✔
420	this._resetInactivityTimeout();	3✔
421	await this.addMessage({ type: MessageType.COMMAND, command });	3✔
422	if (this._debug)	3!
423	console.log('Received assistant command ' + command);	3✔
424
425	await this._loop.handleCommand({ type: 'command', utterance: command, platformData });	3✔
426	}
427
428	async handleParsedCommand(root : any, title ?: string, platformData : PlatformData = {}) : Promise<void> {	73✔
429	const command = `\\r ${typeof root === 'string' ? root : JSON.stringify(root)}`;	73!
430	this.stats.hit('sabrina-parsed-command');	73✔
431	this.emit('active');	73✔
432	this._resetInactivityTimeout();	73✔
433	if (typeof root === 'string')	73!
434	root = JSON.parse(root);	×
435	await this.addMessage({ type: MessageType.COMMAND, command: title \|\| command, json: root });	73✔
436
437	if (this._debug)	73!
438	console.log('Received pre-parsed assistant command');	73✔
439	if (root.example_id) {	73!
440	this.thingpedia.clickExample(root.example_id).catch((e) => {	×
441	console.error('Failed to record example click: ' + e.message);	×
442	});
443	}
444
445	if ('program' in root)	73!
446	return this.handleThingTalk(root.program, platformData);	×
447
448	const { code, entities } = root;	73✔
449	for (const name in entities) {	73✔
450	if (name.startsWith('SLOT_')) {	×
451	const slotname = root.slots![parseInt(name.substring('SLOT_'.length))];	×
452	const slotType = ThingTalk.Type.fromString(root.slotTypes![slotname]);	×
453	const value = ThingTalk.Ast.Value.fromJSON(slotType, entities[name]);	×
454	entities[name] = value;	×
455	}
456	}
457
458	const parsed = await ThingTalkUtils.parsePrediction(code, entities, {	73✔
459	thingpediaClient: this._engine.thingpedia,
460	schemaRetriever: this._engine.schemas,
461	loadMetadata: true
462	}, true);
463	return this._loop.handleCommand({ type: 'thingtalk', parsed, platformData });	73✔
464	}
465
466	async handleThingTalk(program : string, platformData : PlatformData = {}) : Promise<void> {	92✔
467	const command = `\\t ${program}`;	92✔
468	this.stats.hit('sabrina-thingtalk-command');	92✔
469	this.emit('active');	92✔
470	this._resetInactivityTimeout();	92✔
471	await this.addMessage({ type: MessageType.COMMAND, command });	92✔
472	if (this._debug)	92!
473	console.log('Received ThingTalk program');	92✔
474
475	const parsed = await ThingTalkUtils.parse(program, {	92✔
476	thingpediaClient: this._engine.thingpedia,
477	schemaRetriever: this._engine.schemas,
478	loadMetadata: true
479	});
480	return this._loop.handleCommand({ type: 'thingtalk', parsed, platformData });	92✔
481	}
482
483	sendReply(message : string, icon : string\|null) {
484	if (this._debug)	106!
485	console.log('Genie says: ' + message);	106✔
486	return this.addMessage({ type: MessageType.TEXT, text: message, icon });	106✔
487	}
488
489	sendMedia(mediaType : 'picture'\|'audio'\|'video', url : string, alt : string\|undefined, icon : string\|null) {
490	if (this._debug)	×
491	console.log('Genie sends ' + mediaType + ': '+ url);	×
NEW 492	return this.addMessage({ type: mediaType as MessageType.AUDIO\|MessageType.VIDEO\|MessageType.PICTURE, url, alt, icon });	×
493	}
494
495	sendRDL(rdl : RDL, icon : string\|null) {
496	if (this._debug)	21!
497	console.log('Genie sends RDL: '+ rdl.callback);	21✔
498	return this.addMessage({ type: MessageType.RDL, rdl, icon });	21✔
499	}
500
501	sendSoundEffect(name : string, exclusive : boolean, icon : string\|null) {
502	if (this._debug)	×
503	console.log('Genie sends sound effect: '+ name);	×
NEW 504	return this.addMessage({ type: MessageType.SOUND_EFFECT, name, exclusive, icon });	×
505	}
506
507	sendChoice(idx : number, title : string) {
508	if (this._expecting !== ValueCategory.MultipleChoice)	2!
509	console.log('UNEXPECTED: sendChoice while not expecting a MultipleChoice');	×
510	if (this._debug)	2!
511	console.log('Genie sends multiple choice button: '+ title);	2✔
512	return this.addMessage({ type: MessageType.CHOICE, idx, title });	2✔
513	}
514
515	sendButton(title : string, json : string) {
516	if (this._debug)	×
517	console.log('Genie sends generic button: '+ title);	×
NEW 518	return this.addMessage({ type: MessageType.BUTTON, json, title });	×
519	}
520
521	sendLink(title : string, url : string) {
522	if (this._debug)	4!
523	console.log('Genie sends link: '+ url);	4✔
524	return this.addMessage({ type: MessageType.LINK, url, title, state: this.getState() });	4✔
525	}
526
527	sendNewProgram(program : {
528	uniqueId : string;
529	name : string;
530	code : string;
531	results : Array<Record<string, unknown>>;
532	errors : string[];
533	icon : string\|null;
534	}) {
535	if (this._debug)	66!
536	console.log('Genie executed new program: '+ program.uniqueId);	66✔
537	return this.addMessage({ type: MessageType.NEW_PROGRAM, ...program });	66✔
538	}
539
540	private get _lastDialogue() {
541	if (this._log.length === 0)	1,378✔
542	return null;	4✔
543	return this._log[this._log.length - 1];	1,374✔
544	}
545
546	private get _lastTurn() {
547	const lastDialogue = this._lastDialogue;	910✔
548	if (!lastDialogue \|\| lastDialogue.turns.length === 0)	910✔
549	return null;	3✔
550	return lastDialogue.turns[lastDialogue.turns.length - 1];	907✔
551	}
552
553	appendNewDialogue() {
554	this._log.push(new DialogueLog());	89✔
555	}
556
557	dialogueFinished() {
558	const last = this._lastDialogue;	90✔
559	if (last)	90!
560	last.finish();	90✔
561	}
562
563	turnFinished() {
564	const last = this._lastTurn;	165✔
565	if (last)	165✔
566	last.finish();	163✔
567	}
568
569	appendNewTurn(turn : DialogueTurnLog) {
570	const last = this._lastDialogue;	189✔
571	if (!last \|\| last.done)	189✔
572	this.appendNewDialogue();	89✔
573	const dialogue = this._lastDialogue!;	189✔
574	dialogue.append(turn);	189✔
575	}
576
577	voteLast(vote : 'up'\|'down') {
578	const last = this._lastTurn;	64✔
579	if (!last)	64!
580	throw new Error('No dialogue is logged');	×
581	last.turn.vote = vote;	64✔
582	}
583
584	commentLast(comment : string) {
585	const last = this._lastTurn;	64✔
586	if (!last)	64!
587	throw new Error('No dialogue is logged');	×
588	last.turn.comment = comment;	64✔
589	}
590
591	updateLog(field : Exclude<keyof DialogueTurn,'agent_timestamp'\|'user_timestamp'>, value : string) {
592	if (this.inRecordingMode) {	627✔
593	let last = this._lastTurn;	617✔
594	if (!last \|\| last.done) {	617✔
595	last = new DialogueTurnLog();	189✔
596	this.appendNewTurn(last);	189✔
597	}
598	last.update(field, value);	617✔
599	}
600	}
601
602	async saveLog() {
603	const dir = path.join(this._engine.platform.getWritableDir(), 'logs');	1✔
604	try {	1✔
605	fs.mkdirSync(dir);	1✔
606	} catch(e) {
607	if (e.code !== 'EEXIST')	×
608	throw e;	×
609	}
610	const logfile = path.join(dir, this.id + '.txt');	1✔
611	const serializer = new DialogueSerializer({ annotations: true });	1✔
612
613	const output = fs.createWriteStream(logfile);	1✔
614
615	serializer.pipe(output);	1✔
616	for (const dialogue of this._log)	1✔
617	serializer.write({ id: this.id, turns: dialogue.turns.map((log) => log.turn) });	189✔
618	serializer.end();	1✔
619
620	await StreamUtils.waitFinish(output);	1✔
621	}
622
623	get log() : string\|null {
624	const log = path.join(this._engine.platform.getWritableDir(), 'logs', this.id + '.txt');	1✔
625	if (!fs.existsSync(log))	1!
626	return null;	×
627	return log;	1✔
628	}
629	}

stanford-oval / genie-toolkit / 1911

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