@jsonstudio/llms 0.6.2172 → 0.6.2979

package/dist/servertool/engine.js

@@ -312,6 +312,7 @@ export async function runServerToolOrchestration(options) {
             return 'unknown';
         const mapping = {
             continue_execution_flow: 'continue_execution',
+            review_flow: 'review',
             stop_message_flow: 'stop_message_auto',
             empty_reply_continue: 'empty_reply_continue',
             apply_patch_guard: 'apply_patch_guard',
@@ -429,6 +430,31 @@ export async function runServerToolOrchestration(options) {
         catch {
             // best-effort only
         }
+        if (event.hookId === 'stop_message_auto' && event.result === 'miss') {
+            const compareContext = readStopMessageCompareContext(options.adapterContext);
+            const summary = formatStopMessageCompareContext(compareContext);
+            try {
+                // eslint-disable-next-line no-console
+                console.log(`${BLUE}[servertool][stop_compare] requestId=${options.requestId} stage=miss flow=none ${summary}${RESET}`);
+            }
+            catch {
+                // best-effort logging
+            }
+            const compareResult = compareContext
+                ? `${compareContext.decision}_${compareContext.reason.toLowerCase().replace(/[^a-z0-9]+/g, '_') || 'unknown'}`
+                : 'unknown_no_context';
+            appendServerToolProgressFileEvent({
+                requestId: options.requestId,
+                flowId: 'none',
+                tool: 'stop_message_auto',
+                stage: 'compare',
+                result: compareResult,
+                message: summary,
+                step: 2,
+                entryEndpoint: options.entryEndpoint,
+                providerProtocol: options.providerProtocol
+            });
+        }
     };
     const logStopCompare = (stage, flowId) => {
         const compareContext = readStopMessageCompareContext(options.adapterContext);
@@ -495,13 +521,28 @@ export async function runServerToolOrchestration(options) {
         providerProtocol: options.providerProtocol,
         providerInvoker: options.providerInvoker,
         reenterPipeline: options.reenterPipeline,
+        clientInjectDispatch: options.clientInjectDispatch,
         onAutoHookTrace: logAutoHookTrace
     };
-    const engineResult = await withTimeout(runServerSideToolEngine(engineOptions), effectiveServerToolTimeoutMs, () => createServerToolTimeoutError({
+    const runEngine = async (overrides) => withTimeout(runServerSideToolEngine({
+        ...engineOptions,
+        ...overrides
+    }), effectiveServerToolTimeoutMs, () => createServerToolTimeoutError({
         requestId: options.requestId,
         phase: 'engine',
         timeoutMs: effectiveServerToolTimeoutMs || serverToolTimeoutMs
     }));
+    // StopMessage owns a dedicated orchestration skeleton:
+    // same trigger/processing semantics as before, but isolated from the generic servertool queue.
+    let engineResult = await runEngine({
+        disableToolCallHandlers: true,
+        includeAutoHookIds: ['stop_message_auto']
+    });
+    if (engineResult.mode === 'passthrough' || !engineResult.execution) {
+        engineResult = await runEngine({
+            excludeAutoHookIds: ['stop_message_auto']
+        });
+    }
     if (engineResult.mode === 'passthrough' || !engineResult.execution) {
         const skipReason = engineResult.mode === 'passthrough' ? 'passthrough' : 'no_execution';
         if (stopSignal.observed) {
@@ -583,7 +624,7 @@ export async function runServerToolOrchestration(options) {
             flowId: engineResult.execution.flowId
         };
     }
-    if (!engineResult.execution.followup || !options.reenterPipeline) {
+    if (!engineResult.execution.followup) {
         logProgress(5, totalSteps, 'completed (no followup)', { flowId });
         return {
             chat: engineResult.finalChatResponse,
@@ -594,6 +635,7 @@ export async function runServerToolOrchestration(options) {
     const isStopMessageFlow = engineResult.execution.flowId === 'stop_message_flow';
     const isClockHoldFlow = engineResult.execution.flowId === 'clock_hold_flow';
     const isContinueExecutionFlow = engineResult.execution.flowId === 'continue_execution_flow';
+    const isReviewFlow = engineResult.execution.flowId === 'review_flow';
     const isEmptyReplyContinue = engineResult.execution.flowId === 'empty_reply_continue';
     const isApplyPatchGuard = engineResult.execution.flowId === 'apply_patch_guard';
     const isExecCommandGuard = engineResult.execution.flowId === 'exec_command_guard';
@@ -602,7 +644,9 @@ export async function runServerToolOrchestration(options) {
     // ServerTool followups must not inherit or inject any routeHint; always route fresh.
     const preserveRouteHint = false;
     const followupPlan = engineResult.execution.followup;
-    const followupEntryEndpoint = engineResult.execution.followup.entryEndpoint ||
+    const followupEntryEndpoint = ('entryEndpoint' in engineResult.execution.followup
+        ? engineResult.execution.followup.entryEndpoint
+        : undefined) ||
         options.entryEndpoint ||
         '/v1/chat/completions';
     const followupPayloadRaw = (() => {
@@ -629,7 +673,12 @@ export async function runServerToolOrchestration(options) {
         }
         return null;
     })();
-    if (!followupPayloadRaw) {
+    const metadataOnlyFollowup = !followupPayloadRaw &&
+        Boolean(followupPlan &&
+            typeof followupPlan === 'object' &&
+            !Array.isArray(followupPlan) &&
+            Object.prototype.hasOwnProperty.call(followupPlan, 'metadata'));
+    if (!followupPayloadRaw && !metadataOnlyFollowup) {
         logProgress(5, totalSteps, 'completed (missing followup payload)', { flowId });
         return {
             chat: engineResult.finalChatResponse,
@@ -637,7 +686,9 @@ export async function runServerToolOrchestration(options) {
             flowId: engineResult.execution.flowId
         };
     }
-    const loopState = buildServerToolLoopState(options.adapterContext, engineResult.execution.flowId, followupPayloadRaw, engineResult.finalChatResponse);
+    const loopState = followupPayloadRaw
+        ? buildServerToolLoopState(options.adapterContext, engineResult.execution.flowId, followupPayloadRaw, engineResult.finalChatResponse)
+        : null;
     const stopMessageReservation = null;
     if (applyAutoLimit && loopState && typeof loopState.repeatCount === 'number' && loopState.repeatCount >= 3) {
         logProgress(5, totalSteps, 'completed (auto limit hit)', { flowId });
@@ -712,7 +763,7 @@ export async function runServerToolOrchestration(options) {
     // For stateful auto-followups (e.g. stop_message_flow / clock_hold_flow / continue_execution_flow),
     // keep the same providerKey/alias.
     // Otherwise the followup requestId suffix would cause round-robin alias switching and compatibility drift.
-    if (isStopMessageFlow || isClockHoldFlow || isContinueExecutionFlow) {
+    if (isStopMessageFlow || isClockHoldFlow || isContinueExecutionFlow || isReviewFlow) {
         const providerKeyRaw = options.adapterContext.providerKey;
         const providerKey = typeof providerKeyRaw === 'string' && providerKeyRaw.trim().length ? providerKeyRaw.trim() : '';
         if (providerKey) {
@@ -722,9 +773,115 @@ export async function runServerToolOrchestration(options) {
     const retryEmptyFollowupOnce = isStopMessageFlow || isEmptyReplyContinue;
     const maxAttempts = retryEmptyFollowupOnce ? 2 : 1;
     const followupRequestId = buildFollowupRequestId(options.requestId, engineResult.execution.followup.requestIdSuffix);
+    const clientInjectOnlyRaw = metadata.clientInjectOnly;
+    const clientInjectOnly = clientInjectOnlyRaw === true ||
+        (typeof clientInjectOnlyRaw === 'string' && clientInjectOnlyRaw.trim().toLowerCase() === 'true');
+    if (clientInjectOnly) {
+        if (!options.clientInjectDispatch) {
+            const wrapped = new ProviderProtocolError('[servertool] client inject dispatcher unavailable', {
+                code: 'SERVERTOOL_FOLLOWUP_FAILED',
+                category: 'INTERNAL_ERROR',
+                details: {
+                    flowId: engineResult.execution.flowId,
+                    requestId: options.requestId,
+                    upstreamCode: 'client_inject_failed',
+                    reason: 'client_inject_dispatcher_unavailable'
+                }
+            });
+            wrapped.status = 502;
+            throw wrapped;
+        }
+        const disconnectWatcher = createClientDisconnectWatcher({
+            adapterContext: options.adapterContext,
+            requestId: options.requestId,
+            flowId: engineResult.execution.flowId
+        });
+        try {
+            const injectFollowupBody = followupPayloadRaw && typeof followupPayloadRaw === 'object' && !Array.isArray(followupPayloadRaw)
+                ? coerceFollowupPayloadStream(followupPayloadRaw, metadata.stream === true)
+                : {};
+            const dispatchResult = await withTimeout(Promise.race([
+                options.clientInjectDispatch({
+                    entryEndpoint: followupEntryEndpoint,
+                    requestId: followupRequestId,
+                    body: injectFollowupBody,
+                    metadata
+                }),
+                disconnectWatcher.promise
+            ]), followupTimeoutMs, () => createServerToolTimeoutError({
+                requestId: options.requestId,
+                phase: 'followup',
+                timeoutMs: followupTimeoutMs,
+                flowId: engineResult.execution.flowId
+            }));
+            if (!dispatchResult || dispatchResult.ok !== true) {
+                const wrapped = new ProviderProtocolError('[servertool.inject] client injection failed', {
+                    code: 'SERVERTOOL_FOLLOWUP_FAILED',
+                    details: {
+                        flowId: engineResult.execution.flowId,
+                        requestId: options.requestId,
+                        upstreamCode: 'client_inject_failed',
+                        reason: dispatchResult && typeof dispatchResult.reason === 'string' && dispatchResult.reason.trim()
+                            ? dispatchResult.reason.trim()
+                            : 'client_inject_not_handled'
+                    }
+                });
+                wrapped.status = 502;
+                throw wrapped;
+            }
+            disconnectWatcher.cancel();
+            const decorated = decorateFinalChatWithServerToolContext(engineResult.finalChatResponse, engineResult.execution);
+            logProgress(5, totalSteps, 'completed (client inject only)', { flowId });
+            return {
+                chat: decorated,
+                executed: true,
+                flowId: engineResult.execution.flowId
+            };
+        }
+        catch (error) {
+            disconnectWatcher.cancel();
+            if (isServerToolClientDisconnectedError(error) || isAdapterClientDisconnected(options.adapterContext)) {
+                logProgress(5, totalSteps, 'completed (client disconnected)', { flowId });
+                return {
+                    chat: engineResult.finalChatResponse,
+                    executed: true,
+                    flowId: engineResult.execution.flowId
+                };
+            }
+            if (isStopMessageFlow) {
+                disableStopMessageAfterFailedFollowup(options.adapterContext, stopMessageReservation);
+                logProgress(5, totalSteps, 'failed (stopMessage client inject failed; state cleared)', { flowId });
+                throw error;
+            }
+            throw error;
+        }
+    }
+    if (!options.reenterPipeline) {
+        const wrapped = new ProviderProtocolError('[servertool] followup requires reenter pipeline', {
+            code: 'SERVERTOOL_FOLLOWUP_FAILED',
+            category: 'INTERNAL_ERROR',
+            details: {
+                flowId: engineResult.execution.flowId,
+                requestId: options.requestId,
+                reason: 'reenter_pipeline_unavailable'
+            }
+        });
+        wrapped.status = 502;
+        throw wrapped;
+    }
+    if (!followupPayloadRaw) {
+        const decorated = decorateFinalChatWithServerToolContext(engineResult.finalChatResponse, engineResult.execution);
+        logProgress(5, totalSteps, 'completed (metadata-only followup without payload)', { flowId });
+        return {
+            chat: decorated,
+            executed: true,
+            flowId: engineResult.execution.flowId
+        };
+    }
+    // Build followup payload for non-client-inject flows
     let followupPayload = coerceFollowupPayloadStream(followupPayloadRaw, metadata.stream === true);
-    if (shouldInjectStopLoopWarning) {
-        appendStopMessageLoopWarning(followupPayload, loopState?.stopPairRepeatCount ?? STOP_MESSAGE_LOOP_WARN_THRESHOLD);
+    if (shouldInjectStopLoopWarning && loopState) {
+        appendStopMessageLoopWarning(followupPayload, loopState.stopPairRepeatCount ?? STOP_MESSAGE_LOOP_WARN_THRESHOLD);
     }
     followupPayload = applyHubFollowupPolicyShadow({
         requestId: followupRequestId,
@@ -819,6 +976,11 @@ export async function runServerToolOrchestration(options) {
             }
             lastError = error;
             if (attempt >= maxAttempts) {
+                if (isStopMessageFlow) {
+                    disableStopMessageAfterFailedFollowup(options.adapterContext, stopMessageReservation);
+                    logProgress(5, totalSteps, 'failed (stopMessage followup failed; state cleared)', { flowId, attempt });
+                    throw error;
+                }
                 const wrapped = new ProviderProtocolError(`[servertool] Followup failed for flow ${engineResult.execution.flowId ?? 'unknown'} ` +
                     `(attempt ${attempt}/${maxAttempts})`, {
                     code: 'SERVERTOOL_FOLLOWUP_FAILED',
@@ -840,18 +1002,8 @@ export async function runServerToolOrchestration(options) {
         : undefined;
     if (retryEmptyFollowupOnce && (!followupBody || isEmptyClientResponsePayload(followupBody))) {
         if (isStopMessageFlow) {
-            // 对 stopMessage：先清理状态，避免后续请求继续触发失败循环；
-            // 若原始响应可用则回退原始响应，否则显式抛错，避免“静默空响应”。
             disableStopMessageAfterFailedFollowup(options.adapterContext, stopMessageReservation);
-            const fallbackOriginal = engineResult.finalChatResponse;
-            if (fallbackOriginal && !isEmptyClientResponsePayload(fallbackOriginal)) {
-                logProgress(5, totalSteps, 'completed (stopMessage followup empty; fallback to original)', { flowId });
-                return {
-                    chat: fallbackOriginal,
-                    executed: true,
-                    flowId: engineResult.execution.flowId
-                };
-            }
+            logProgress(5, totalSteps, 'failed (stopMessage followup empty; state cleared)', { flowId });
             throw createEmptyFollowupError({
                 flowId: engineResult.execution.flowId,
                 requestId: options.requestId,
@@ -976,6 +1128,8 @@ function disableStopMessageAfterFailedFollowup(adapterContext, reservation) {
         state.stopMessageSource = undefined;
         state.stopMessageUpdatedAt = now;
         state.stopMessageLastUsedAt = now;
+        state.stopMessageAiSeedPrompt = undefined;
+        state.stopMessageAiHistory = undefined;
         saveRoutingInstructionStateSync(key, state);
     }
     catch {
@@ -988,67 +1142,30 @@ function resolveStickyKeyFromAdapterContext(adapterContext) {
     }
     const record = adapterContext;
     const runtime = readRuntimeMetadata(record);
-    const providerProtocol = readTextFromAny(record.providerProtocol) ||
-        readTextFromAny(runtime?.providerProtocol) ||
-        readTextFromAny(record.provider_protocol) ||
-        readTextFromAny(runtime?.provider_protocol);
-    if (providerProtocol.trim().toLowerCase() === 'openai-responses') {
-        const previousRequestId = resolveResponsesResumePreviousRequestId(record, runtime);
-        if (previousRequestId) {
-            return previousRequestId;
-        }
-        const requestId = resolveStickyRequestId(record, runtime);
-        if (requestId) {
-            return requestId;
-        }
-    }
-    const sessionId = readTextFromAny(record.sessionId) ||
-        readTextFromAny(record.session_id) ||
-        readTextFromAny(runtime?.sessionId) ||
-        readTextFromAny(runtime?.session_id);
-    const conversationId = readTextFromAny(record.conversationId) ||
-        readTextFromAny(record.conversation_id) ||
-        readTextFromAny(runtime?.conversationId) ||
-        readTextFromAny(runtime?.conversation_id);
-    if (sessionId) {
-        return `session:${sessionId}`;
-    }
-    if (conversationId) {
-        return `conversation:${conversationId}`;
-    }
-    const requestId = resolveStickyRequestId(record, runtime);
-    return requestId || undefined;
-}
-function resolveStickyRequestId(context, runtime) {
-    return (readTextFromAny(context.requestId) ||
-        readTextFromAny(context.request_id) ||
-        readTextFromAny(runtime?.requestId) ||
-        readTextFromAny(runtime?.request_id));
-}
-function resolveResponsesResumePreviousRequestId(context, runtime) {
-    const contextMetadata = asRecord(context.metadata);
-    const contextMetadataContext = asRecord(contextMetadata?.context);
-    const originalRequest = asRecord(context.originalRequest);
-    const originalMetadata = asRecord(originalRequest?.metadata);
-    const candidates = [
-        context.responsesResume,
-        contextMetadata?.responsesResume,
-        contextMetadataContext?.responsesResume,
-        originalRequest?.responsesResume,
-        originalMetadata?.responsesResume,
-        runtime?.responsesResume
-    ];
-    for (const candidate of candidates) {
-        const resume = asRecord(candidate);
-        if (!resume) {
-            continue;
-        }
-        const previousRequestId = readTextFromAny(resume.previousRequestId) || readTextFromAny(resume.previous_request_id);
-        if (previousRequestId) {
-            return previousRequestId;
-        }
+    const explicitScope = readTextFromAny(runtime?.stopMessageClientInjectSessionScope) ||
+        readTextFromAny(runtime?.stopMessageClientInjectScope) ||
+        readTextFromAny(record.stopMessageClientInjectSessionScope) ||
+        readTextFromAny(record.stopMessageClientInjectScope);
+    if (explicitScope && explicitScope.startsWith('tmux:')) {
+        return explicitScope;
+    }
+    const metadata = asRecord(record.metadata);
+    const tmuxSessionId = readTextFromAny(record.clientTmuxSessionId) ||
+        readTextFromAny(record.client_tmux_session_id) ||
+        readTextFromAny(record.tmuxSessionId) ||
+        readTextFromAny(record.tmux_session_id) ||
+        readTextFromAny(runtime?.clientTmuxSessionId) ||
+        readTextFromAny(runtime?.client_tmux_session_id) ||
+        readTextFromAny(runtime?.tmuxSessionId) ||
+        readTextFromAny(runtime?.tmux_session_id) ||
+        readTextFromAny(metadata?.clientTmuxSessionId) ||
+        readTextFromAny(metadata?.client_tmux_session_id) ||
+        readTextFromAny(metadata?.tmuxSessionId) ||
+        readTextFromAny(metadata?.tmux_session_id);
+    if (!tmuxSessionId) {
+        return undefined;
     }
-    return '';
+    return `tmux:${tmuxSessionId}`;
 }
 function asRecord(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {

package/dist/servertool/handlers/antigravity-thought-signature-bootstrap.js

@@ -57,7 +57,7 @@ function buildClockToolSchema() {
         type: 'function',
         function: {
             name: 'clock',
-            description: 'Time + Alarm for this session. Use get/schedule/update/list/cancel/clear. Scheduled reminders will be injected into future requests.',
+            description: 'Time + Alarm for this session. If waiting longer than 2 minutes is required, call clock.schedule now (do not only promise to wait). Format example: {"action":"schedule","items":[{"dueAt":"<ISO8601>","task":"<exact follow-up action>","tool":"<tool-name-or-empty>","arguments":"<json-string-or-{}>"}],"taskId":""}. Use get/schedule/update/list/cancel/clear. Scheduled reminders will be injected into future requests.',
             strict: true,
             parameters: {
                 type: 'object',
@@ -65,7 +65,7 @@ function buildClockToolSchema() {
                     action: {
                         type: 'string',
                         enum: ['get', 'schedule', 'update', 'list', 'cancel', 'clear'],
-                        description: 'Get current time, or schedule/update/list/cancel/clear session-scoped reminders.'
+                        description: 'Get current time, or schedule/update/list/cancel/clear session-scoped reminders. If waiting longer than 2 minutes is required, use action="schedule" immediately.'
                     },
                     items: {
                         type: 'array',

package/dist/servertool/handlers/clock.js

@@ -385,7 +385,7 @@ const handler = async (ctx) => {
         return respond({
             ok: false,
             action,
-            message: 'clock requires session scope (sessionId/conversationId or clockDaemonId).'
+            message: 'clock requires tmux session scope (clientTmuxSessionId/tmuxSessionId).'
         });
     }
     if (action === 'list') {

package/dist/servertool/handlers/continue-execution.js

@@ -54,7 +54,7 @@ const handler = async (ctx) => {
     }
     const parsed = parseToolArguments(toolCall);
     const reason = normalizeReason(parsed);
-    const followupText = '继续执行当前任务，不要中断到总结/汇报。仅在任务真正完成后再给最终总结。该工具用于避免打断会话并提高执行效率。';
+    const followupText = '继续执行当前任务。强制规则：凡是“仅汇报进度”或“准备 stop/end_turn”，都必须先调用 CONTINUE execution（continue_execution，可传 {"reason":"progress_update"}）。进度汇报顺序必须是：1) 先调 continue_execution；2) 最多 5 行简短汇报；3) 立即继续真实动作。进度汇报后禁止 finish_reason=stop/end_turn；仅在任务真正完成后才允许最终总结。';
     return {
         flowId: FLOW_ID,
         finalize: async () => {
@@ -64,7 +64,7 @@ const handler = async (ctx) => {
                 noop: true,
                 action: 'continue_execution',
                 ...(reason ? { reason } : {}),
-                message: 'No-op acknowledged. Continue execution without pausing for status summaries or ending turn early. If you were about to stop/end_turn, emit continue_execution first; server auto-followup keeps execution moving.'
+                message: 'No-op acknowledged. continue_execution is mandatory before progress-only summaries or stop/end_turn. Do not emit finish_reason=stop/end_turn for progress-only updates. After summary, continue real actions immediately; server auto-followup keeps execution moving.'
             });
             return {
                 chatResponse: patched,
@@ -78,9 +78,13 @@ const handler = async (ctx) => {
                                 { op: 'preserve_tools' },
                                 { op: 'ensure_standard_tools' },
                                 { op: 'append_assistant_message', required: true },
-                                { op: 'append_tool_messages_from_tool_outputs', required: true },
-                                { op: 'append_user_text', text: followupText }
+                                { op: 'append_tool_messages_from_tool_outputs', required: true }
                             ]
+                        },
+                        metadata: {
+                            clientInjectOnly: true,
+                            clientInjectText: '继续执行',
+                            clientInjectSource: 'servertool.continue_execution'
                         }
                     }
                 }

package/dist/servertool/handlers/followup-request-builder.js

@@ -331,7 +331,7 @@ function buildStandardFollowupTools() {
             type: 'function',
             function: {
                 name: 'continue_execution',
-                description: 'No-op control tool. Use this before summaries or before ending the turn. If you are about to return stop/end_turn, emit continue_execution first instead of ending directly. Keep it lightweight; server auto-followup continues execution.',
+                description: 'No-op control tool for progress reporting without interrupting execution. Mandatory rule: if you are giving a progress-only update or are about to stop/end_turn, you MUST call continue_execution first (example arguments: {"reason":"progress_update"}). Required sequence: (1) call continue_execution, (2) provide a brief progress summary (<=5 lines), (3) immediately continue real actions. Do NOT emit finish_reason=stop/end_turn for progress-only updates. Only stop when the overall goal is complete. If waiting longer than 2 minutes is needed, use clock.schedule instead.',
                 parameters: {
                     type: 'object',
                     properties: {},
@@ -340,6 +340,23 @@ function buildStandardFollowupTools() {
                 }
             }
         },
+        {
+            type: 'function',
+            function: {
+                name: 'review',
+                description: 'Independent reviewer handoff. Use when you need an external evidence-based code review before claiming completion. The review result will be injected back to client as next-step guidance. Do not stop immediately after this tool.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        goal: { type: 'string' },
+                        context: { type: 'string' },
+                        focus: { type: 'string' }
+                    },
+                    required: ['goal', 'context', 'focus'],
+                    additionalProperties: false
+                }
+            }
+        },
         {
             type: 'function',
             function: {

package/dist/servertool/handlers/gemini-empty-reply-continue.js

@@ -186,11 +186,17 @@ function extractResponsesOutputText(base) {
             const pType = typeof part.type === 'string'
                 ? String(part.type).trim().toLowerCase()
                 : '';
-            if (pType === 'output_text') {
+            if (pType === 'output_text' || pType === 'text' || pType === 'input_text') {
                 const text = typeof part.text === 'string' ? String(part.text) : '';
                 if (text.trim().length)
                     chunks.push(text.trim());
+                continue;
             }
+            const fallback = typeof part.content === 'string'
+                ? String(part.content).trim()
+                : '';
+            if (fallback.length)
+                chunks.push(fallback);
         }
     }
     return chunks.join('\n').trim();