116 lines
4.4 KiB
JavaScript
116 lines
4.4 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.runAssistantAddressLaneRuntime = runAssistantAddressLaneRuntime;
|
|
function limitedCategory(addressLane) {
|
|
return typeof addressLane?.debug?.limited_reason_category === "string"
|
|
? addressLane.debug.limited_reason_category
|
|
: null;
|
|
}
|
|
async function runAssistantAddressLaneRuntime(input) {
|
|
const retryAudit = {
|
|
attempted: false,
|
|
reason: null,
|
|
initial_limited_category: null,
|
|
retry_message: null,
|
|
retry_used_followup_context: false,
|
|
retry_result_category: null
|
|
};
|
|
let pendingLimited = null;
|
|
const evaluateAddressLane = (addressLane, messageUsed, carryMeta) => {
|
|
if (!addressLane?.handled) {
|
|
return { action: "continue" };
|
|
}
|
|
if (!input.isRetryableAddressLimitedResult(addressLane)) {
|
|
return {
|
|
action: "return",
|
|
selection: {
|
|
addressLane,
|
|
messageUsed,
|
|
carryMeta
|
|
}
|
|
};
|
|
}
|
|
if (!pendingLimited) {
|
|
pendingLimited = {
|
|
addressLane,
|
|
messageUsed,
|
|
carryMeta
|
|
};
|
|
}
|
|
return { action: "continue" };
|
|
};
|
|
if (input.shouldPreferContextualLane) {
|
|
const contextualAddressLane = await input.runAddressLaneAttempt(input.addressInputMessage, input.carryover);
|
|
const decision = evaluateAddressLane(contextualAddressLane, input.addressInputMessage, input.carryover);
|
|
if (decision.action === "return") {
|
|
return {
|
|
handled: true,
|
|
selection: decision.selection,
|
|
retryAudit
|
|
};
|
|
}
|
|
}
|
|
const primaryAddressLane = await input.runAddressLaneAttempt(input.addressInputMessage, null);
|
|
const primaryDecision = evaluateAddressLane(primaryAddressLane, input.addressInputMessage, null);
|
|
if (primaryDecision.action === "return") {
|
|
return {
|
|
handled: true,
|
|
selection: primaryDecision.selection,
|
|
retryAudit
|
|
};
|
|
}
|
|
if (!input.shouldPreferContextualLane && input.carryover?.followupContext) {
|
|
const contextualAddressLane = await input.runAddressLaneAttempt(input.addressInputMessage, input.carryover);
|
|
const contextualDecision = evaluateAddressLane(contextualAddressLane, input.addressInputMessage, input.carryover);
|
|
if (contextualDecision.action === "return") {
|
|
return {
|
|
handled: true,
|
|
selection: contextualDecision.selection,
|
|
retryAudit
|
|
};
|
|
}
|
|
}
|
|
const pendingLimitedSelection = pendingLimited;
|
|
if (pendingLimitedSelection && input.canRetryWithRawUserMessage) {
|
|
retryAudit.attempted = true;
|
|
retryAudit.reason = "limited_result_retry_with_raw_message";
|
|
retryAudit.initial_limited_category = limitedCategory(pendingLimitedSelection?.addressLane ?? null);
|
|
retryAudit.retry_message = input.userMessage;
|
|
if (input.carryover?.followupContext) {
|
|
retryAudit.retry_used_followup_context = true;
|
|
const rawContextualLane = await input.runAddressLaneAttempt(input.userMessage, input.carryover);
|
|
const rawContextualDecision = evaluateAddressLane(rawContextualLane, input.userMessage, input.carryover);
|
|
if (rawContextualDecision.action === "return") {
|
|
retryAudit.retry_result_category = limitedCategory(rawContextualDecision.selection.addressLane);
|
|
return {
|
|
handled: true,
|
|
selection: rawContextualDecision.selection,
|
|
retryAudit
|
|
};
|
|
}
|
|
}
|
|
const rawPrimaryLane = await input.runAddressLaneAttempt(input.userMessage, null);
|
|
retryAudit.retry_result_category = limitedCategory(rawPrimaryLane);
|
|
const rawPrimaryDecision = evaluateAddressLane(rawPrimaryLane, input.userMessage, null);
|
|
if (rawPrimaryDecision.action === "return") {
|
|
return {
|
|
handled: true,
|
|
selection: rawPrimaryDecision.selection,
|
|
retryAudit
|
|
};
|
|
}
|
|
}
|
|
if (pendingLimited) {
|
|
return {
|
|
handled: true,
|
|
selection: pendingLimited,
|
|
retryAudit
|
|
};
|
|
}
|
|
return {
|
|
handled: false,
|
|
selection: null,
|
|
retryAudit
|
|
};
|
|
}
|