@theia/ai-core 1.61.0-next.8 → 1.62.0-next.3

package/src/browser/frontend-prompt-customization-service.ts

@@ -519,46 +519,93 @@ export class FrontendPromptCustomizationServiceImpl implements PromptCustomizati
     }
 
     async getCustomAgents(): Promise<CustomAgentDescription[]> {
-        const customAgentYamlUri = (await this.getTemplatesDirectoryURI()).resolve('customAgents.yml');
+        const agentsById = new Map<string, CustomAgentDescription>();
+        // First, process additional (workspace) template directories to give them precedence
+        for (const dirPath of this.additionalTemplateDirs) {
+            const dirURI = URI.fromFilePath(dirPath);
+            await this.loadCustomAgentsFromDirectory(dirURI, agentsById);
+        }
+        // Then process global template directory (only adding agents that don't conflict)
+        const globalTemplateDir = await this.getTemplatesDirectoryURI();
+        await this.loadCustomAgentsFromDirectory(globalTemplateDir, agentsById);
+        // Return the merged list of agents
+        return Array.from(agentsById.values());
+    }
+
+    /**
+     * Load custom agents from a specific directory
+     * @param directoryURI The URI of the directory to load from
+     * @param agentsById Map to store the loaded agents by ID
+     */
+    protected async loadCustomAgentsFromDirectory(
+        directoryURI: URI,
+        agentsById: Map<string, CustomAgentDescription>
+    ): Promise<void> {
+        const customAgentYamlUri = directoryURI.resolve('customAgents.yml');
         const yamlExists = await this.fileService.exists(customAgentYamlUri);
         if (!yamlExists) {
-            return [];
+            return;
         }
-        const fileContent = await this.fileService.read(customAgentYamlUri, { encoding: 'utf-8' });
+
         try {
+            const fileContent = await this.fileService.read(customAgentYamlUri, { encoding: 'utf-8' });
             const doc = load(fileContent.value);
+
             if (!Array.isArray(doc) || !doc.every(entry => CustomAgentDescription.is(entry))) {
-                console.debug('Invalid customAgents.yml file content');
-                return [];
+                console.debug(`Invalid customAgents.yml file content in ${directoryURI.toString()}`);
+                return;
             }
+
             const readAgents = doc as CustomAgentDescription[];
-            // make sure all agents are unique (id and name)
-            const uniqueAgentIds = new Set<string>();
-            const uniqueAgents: CustomAgentDescription[] = [];
-            readAgents.forEach(agent => {
-                if (uniqueAgentIds.has(agent.id)) {
-                    return;
+
+            // Add agents to the map if they don't already exist
+            for (const agent of readAgents) {
+                if (!agentsById.has(agent.id)) {
+                    agentsById.set(agent.id, agent);
                 }
-                uniqueAgentIds.add(agent.id);
-                uniqueAgents.push(agent);
-            });
-            return uniqueAgents;
+            }
         } catch (e) {
-            console.debug(e.message, e);
-            return [];
+            console.debug(`Error loading customAgents.yml from ${directoryURI.toString()}: ${e.message}`, e);
         }
     }
 
-    async openCustomAgentYaml(): Promise<void> {
-        const customAgentYamlUri = (await this.getTemplatesDirectoryURI()).resolve('customAgents.yml');
+    /**
+     * Returns all locations of existing customAgents.yml files and potential locations where
+     * new customAgents.yml files could be created.
+     *
+     * @returns An array of objects containing the URI and whether the file exists
+     */
+    async getCustomAgentsLocations(): Promise<{ uri: URI, exists: boolean }[]> {
+        const locations: { uri: URI, exists: boolean }[] = [];
+        // Check global template directory
+        const globalTemplateDir = await this.getTemplatesDirectoryURI();
+        const globalAgentsUri = globalTemplateDir.resolve('customAgents.yml');
+        const globalExists = await this.fileService.exists(globalAgentsUri);
+        locations.push({ uri: globalAgentsUri, exists: globalExists });
+        // Check additional (workspace) template directories
+        for (const dirPath of this.additionalTemplateDirs) {
+            const dirURI = URI.fromFilePath(dirPath);
+            const agentsUri = dirURI.resolve('customAgents.yml');
+            const exists = await this.fileService.exists(agentsUri);
+            locations.push({ uri: agentsUri, exists: exists });
+        }
+        return locations;
+    }
+
+    /**
+     * Opens an existing customAgents.yml file at the given URI, or creates a new one if it doesn't exist.
+     *
+     * @param uri The URI of the customAgents.yml file to open or create
+     */
+    async openCustomAgentYaml(uri: URI): Promise<void> {
         const content = dump([templateEntry]);
-        if (! await this.fileService.exists(customAgentYamlUri)) {
-            await this.fileService.createFile(customAgentYamlUri, BinaryBuffer.fromString(content));
+        if (! await this.fileService.exists(uri)) {
+            await this.fileService.createFile(uri, BinaryBuffer.fromString(content));
         } else {
-            const fileContent = (await this.fileService.readFile(customAgentYamlUri)).value;
-            await this.fileService.writeFile(customAgentYamlUri, BinaryBuffer.concat([fileContent, BinaryBuffer.fromString(content)]));
+            const fileContent = (await this.fileService.readFile(uri)).value;
+            await this.fileService.writeFile(uri, BinaryBuffer.concat([fileContent, BinaryBuffer.fromString(content)]));
         }
-        const openHandler = await this.openerService.getOpener(customAgentYamlUri);
-        openHandler.open(customAgentYamlUri);
+        const openHandler = await this.openerService.getOpener(uri);
+        openHandler.open(uri);
     }
 }

package/src/browser/frontend-variable-service.ts

@@ -14,10 +14,21 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Disposable } from '@theia/core';
-import { FrontendApplicationContribution } from '@theia/core/lib/browser';
-import { injectable } from '@theia/core/shared/inversify';
-import { AIVariableContext, AIVariableResolutionRequest, AIVariableService, DefaultAIVariableService } from '../common';
+import { Disposable, MessageService, Prioritizeable } from '@theia/core';
+import { FrontendApplicationContribution, OpenerService, open } from '@theia/core/lib/browser';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import {
+    AIVariable,
+    AIVariableArg,
+    AIVariableContext,
+    AIVariableOpener,
+    AIVariableResolutionRequest,
+    AIVariableResourceResolver,
+    AIVariableService,
+    DefaultAIVariableService,
+    PromptText
+} from '../common';
+import * as monaco from '@theia/monaco-editor-core';
 
 export type AIVariableDropHandler = (event: DragEvent, context: AIVariableContext) => Promise<AIVariableDropResult | undefined>;
 
@@ -26,11 +37,52 @@ export interface AIVariableDropResult {
     text?: string
 };
 
+export interface AIVariableCompletionContext {
+    /** Portion of user input to be used for filtering completion candidates. */
+    userInput: string;
+    /** The range of suggestion completions. */
+    range: monaco.Range
+    /** A prefix to be applied to each completion item's text */
+    prefix: string
+}
+
+export namespace AIVariableCompletionContext {
+    export function get(
+        variableName: string,
+        model: monaco.editor.ITextModel,
+        position: monaco.Position,
+        matchString?: string
+    ): AIVariableCompletionContext | undefined {
+        const lineContent = model.getLineContent(position.lineNumber);
+        const indexOfVariableTrigger = lineContent.lastIndexOf(matchString ?? PromptText.VARIABLE_CHAR, position.column - 1);
+
+        // check if there is a variable trigger and no space typed between the variable trigger and the cursor
+        if (indexOfVariableTrigger === -1 || lineContent.substring(indexOfVariableTrigger).includes(' ')) {
+            return undefined;
+        }
+
+        // determine whether we are providing completions before or after the variable argument separator
+        const indexOfVariableArgSeparator = lineContent.lastIndexOf(PromptText.VARIABLE_SEPARATOR_CHAR, position.column - 1);
+        const triggerCharIndex = Math.max(indexOfVariableTrigger, indexOfVariableArgSeparator);
+
+        const userInput = lineContent.substring(triggerCharIndex + 1, position.column - 1);
+        const range = new monaco.Range(position.lineNumber, triggerCharIndex + 2, position.lineNumber, position.column);
+        const matchVariableChar = lineContent[triggerCharIndex] === (matchString ? matchString : PromptText.VARIABLE_CHAR);
+        const prefix = matchVariableChar ? variableName + PromptText.VARIABLE_SEPARATOR_CHAR : '';
+        return { range, userInput, prefix };
+    }
+}
+
 export const FrontendVariableService = Symbol('FrontendVariableService');
 export interface FrontendVariableService extends AIVariableService {
     registerDropHandler(handler: AIVariableDropHandler): Disposable;
     unregisterDropHandler(handler: AIVariableDropHandler): void;
     getDropResult(event: DragEvent, context: AIVariableContext): Promise<AIVariableDropResult>;
+
+    registerOpener(variable: AIVariable, opener: AIVariableOpener): Disposable;
+    unregisterOpener(variable: AIVariable, opener: AIVariableOpener): void;
+    getOpener(name: string, arg: string | undefined, context: AIVariableContext): Promise<AIVariableOpener | undefined>;
+    open(variable: AIVariableArg, context?: AIVariableContext): Promise<void>
 }
 
 export interface FrontendVariableContribution {
@@ -38,9 +90,13 @@ export interface FrontendVariableContribution {
 }
 
 @injectable()
-export class DefaultFrontendVariableService extends DefaultAIVariableService implements FrontendApplicationContribution {
+export class DefaultFrontendVariableService extends DefaultAIVariableService implements FrontendApplicationContribution, FrontendVariableService {
     protected dropHandlers = new Set<AIVariableDropHandler>();
 
+    @inject(MessageService) protected readonly messageService: MessageService;
+    @inject(AIVariableResourceResolver) protected readonly aiResourceResolver: AIVariableResourceResolver;
+    @inject(OpenerService) protected readonly openerService: OpenerService;
+
     onStart(): void {
         this.initContributions();
     }
@@ -68,4 +124,58 @@ export class DefaultFrontendVariableService extends DefaultAIVariableService imp
         }
         return { variables, text };
     }
+
+    registerOpener(variable: AIVariable, opener: AIVariableOpener): Disposable {
+        const key = this.getKey(variable.name);
+        if (!this.variables.get(key)) {
+            this.variables.set(key, variable);
+            this.onDidChangeVariablesEmitter.fire();
+        }
+        const openers = this.openers.get(key) ?? [];
+        openers.push(opener);
+        this.openers.set(key, openers);
+        return Disposable.create(() => this.unregisterOpener(variable, opener));
+    }
+
+    unregisterOpener(variable: AIVariable, opener: AIVariableOpener): void {
+        const key = this.getKey(variable.name);
+        const registeredOpeners = this.openers.get(key);
+        registeredOpeners?.splice(registeredOpeners.indexOf(opener), 1);
+    }
+
+    async getOpener(name: string, arg: string | undefined, context: AIVariableContext = {}): Promise<AIVariableOpener | undefined> {
+        const variable = this.getVariable(name);
+        return variable && Prioritizeable.prioritizeAll(
+            this.openers.get(this.getKey(name)) ?? [],
+            opener => (async () => opener.canOpen({ variable, arg }, context))().catch(() => 0)
+        )
+            .then(prioritized => prioritized.at(0)?.value);
+    }
+
+    async open(request: AIVariableArg, context?: AIVariableContext | undefined): Promise<void> {
+        const { variableName, arg } = this.parseRequest(request);
+        const variable = this.getVariable(variableName);
+        if (!variable) {
+            this.messageService.warn('No variable found for open request.');
+            return;
+        }
+        const opener = await this.getOpener(variableName, arg, context);
+        try {
+            return opener ? opener.open({ variable, arg }, context ?? {}) : this.openReadonly({ variable, arg }, context);
+        } catch (err) {
+            console.error('Unable to open variable:', err);
+            this.messageService.error('Unable to display variable value.');
+        }
+    }
+
+    protected async openReadonly(request: AIVariableResolutionRequest, context: AIVariableContext = {}): Promise<void> {
+        const resolved = await this.resolveVariable(request, context);
+        if (resolved === undefined) {
+            this.messageService.warn('Unable to resolve variable.');
+            return;
+        }
+        const resource = this.aiResourceResolver.getOrCreate(request, context, resolved.value);
+        await open(this.openerService, resource.uri);
+        resource.dispose();
+    }
 }

package/src/common/ai-variable-resource.ts

@@ -0,0 +1,86 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import * as deepEqual from 'fast-deep-equal';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { Resource, URI, generateUuid } from '@theia/core';
+import { AIVariableContext, AIVariableResolutionRequest } from './variable-service';
+import stableJsonStringify = require('fast-json-stable-stringify');
+import { ConfigurableInMemoryResources, ConfigurableMutableReferenceResource } from './configurable-in-memory-resources';
+
+export const AI_VARIABLE_RESOURCE_SCHEME = 'ai-variable';
+export const NO_CONTEXT_AUTHORITY = 'context-free';
+
+@injectable()
+export class AIVariableResourceResolver {
+    @inject(ConfigurableInMemoryResources) protected readonly inMemoryResources: ConfigurableInMemoryResources;
+
+    @postConstruct()
+    protected init(): void {
+        this.inMemoryResources.onWillDispose(resource => this.cache.delete(resource.uri.toString()));
+    }
+
+    protected readonly cache = new Map<string, [Resource, AIVariableContext]>();
+
+    getOrCreate(request: AIVariableResolutionRequest, context: AIVariableContext, value: string): ConfigurableMutableReferenceResource {
+        const uri = this.toUri(request, context);
+        try {
+            const existing = this.inMemoryResources.resolve(uri);
+            existing.update({ contents: value });
+            return existing;
+        } catch { /* No-op */ }
+        const fresh = this.inMemoryResources.add(uri, { contents: value, readOnly: true, initiallyDirty: false });
+        const key = uri.toString();
+        this.cache.set(key, [fresh, context]);
+        return fresh;
+    }
+
+    protected toUri(request: AIVariableResolutionRequest, context: AIVariableContext): URI {
+        return URI.fromComponents({
+            scheme: AI_VARIABLE_RESOURCE_SCHEME,
+            query: stableJsonStringify({ arg: request.arg, name: request.variable.name }),
+            path: '/',
+            authority: this.toAuthority(context),
+            fragment: ''
+        });
+    }
+
+    protected toAuthority(context: AIVariableContext): string {
+        try {
+            if (deepEqual(context, {})) { return NO_CONTEXT_AUTHORITY; }
+            for (const [resource, cachedContext] of this.cache.values()) {
+                if (deepEqual(context, cachedContext)) {
+                    return resource.uri.authority;
+                }
+            }
+        } catch (err) {
+            // Mostly that deep equal could overflow the stack, but it should run into === or inequality before that.
+            console.warn('Problem evaluating context in AIVariableResourceResolver', err);
+        }
+        return generateUuid();
+    }
+
+    fromUri(uri: URI): { variableName: string, arg: string | undefined } | undefined {
+        if (uri.scheme !== AI_VARIABLE_RESOURCE_SCHEME) { return undefined; }
+        try {
+            const { name: variableName, arg } = JSON.parse(uri.query);
+            return variableName ? {
+                variableName,
+                arg,
+            } : undefined;
+        } catch { return undefined; }
+    }
+}

package/src/common/configurable-in-memory-resources.ts

@@ -0,0 +1,156 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclispeSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable } from '@theia/core/shared/inversify';
+import { SyncReferenceCollection, Reference, ResourceResolver, Resource, Event, Emitter, URI } from '@theia/core';
+import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
+
+@injectable()
+/** For creating highly configurable in-memory resources */
+export class ConfigurableInMemoryResources implements ResourceResolver {
+
+    protected readonly resources = new SyncReferenceCollection<string, ConfigurableMutableResource>(uri => new ConfigurableMutableResource(new URI(uri)));
+
+    get onWillDispose(): Event<ConfigurableMutableResource> {
+        return this.resources.onWillDispose;
+    }
+
+    add(uri: URI, options: ResourceInitializationOptions): ConfigurableMutableReferenceResource {
+        const resourceUri = uri.toString();
+        if (this.resources.has(resourceUri)) {
+            throw new Error(`Cannot add already existing in-memory resource '${resourceUri}'`);
+        }
+        const resource = this.acquire(resourceUri);
+        resource.update(options);
+        return resource;
+    }
+
+    update(uri: URI, options: ResourceInitializationOptions): Resource {
+        const resourceUri = uri.toString();
+        const resource = this.resources.get(resourceUri);
+        if (!resource) {
+            throw new Error(`Cannot update non-existent in-memory resource '${resourceUri}'`);
+        }
+        resource.update(options);
+        return resource;
+    }
+
+    resolve(uri: URI): ConfigurableMutableReferenceResource {
+        const uriString = uri.toString();
+        if (!this.resources.has(uriString)) {
+            throw new Error(`In memory '${uriString}' resource does not exist.`);
+        }
+        return this.acquire(uriString);
+    }
+
+    protected acquire(uri: string): ConfigurableMutableReferenceResource {
+        const reference = this.resources.acquire(uri);
+        return new ConfigurableMutableReferenceResource(reference);
+    }
+}
+
+export type ResourceInitializationOptions = Pick<Resource, 'autosaveable' | 'initiallyDirty' | 'readOnly'>
+    & { contents?: string | Promise<string>, onSave?: Resource['saveContents'] };
+
+export class ConfigurableMutableResource implements Resource {
+    protected readonly onDidChangeContentsEmitter = new Emitter<void>();
+    readonly onDidChangeContents = this.onDidChangeContentsEmitter.event;
+    protected fireDidChangeContents(): void {
+        this.onDidChangeContentsEmitter.fire();
+    }
+
+    protected readonly onDidChangeReadonlyEmitter = new Emitter<boolean | MarkdownString>();
+    readonly onDidChangeReadOnly = this.onDidChangeReadonlyEmitter.event;
+
+    constructor(readonly uri: URI, protected options?: ResourceInitializationOptions) { }
+
+    get readOnly(): Resource['readOnly'] {
+        return this.options?.readOnly;
+    }
+
+    get autosaveable(): boolean {
+        return this.options?.autosaveable !== false;
+    }
+
+    get initiallyDirty(): boolean {
+        return !!this.options?.initiallyDirty;
+    }
+
+    readContents(): Promise<string> {
+        return Promise.resolve(this.options?.contents ?? '');
+    }
+
+    async saveContents(contents: string): Promise<void> {
+        await this.options?.onSave?.(contents);
+        this.update({ contents });
+    }
+
+    update(options: ResourceInitializationOptions): void {
+        const didContentsChange = 'contents' in options && options.contents !== this.options?.contents;
+        const didReadOnlyChange = 'readOnly' in options && options.readOnly !== this.options?.readOnly;
+        this.options = { ...this.options, ...options };
+        if (didContentsChange) {
+            this.onDidChangeContentsEmitter.fire();
+        }
+        if (didReadOnlyChange) {
+            this.onDidChangeReadonlyEmitter.fire(this.readOnly ?? false);
+        }
+    }
+
+    dispose(): void {
+        this.onDidChangeContentsEmitter.dispose();
+    }
+}
+
+export class ConfigurableMutableReferenceResource implements Resource {
+    constructor(protected reference: Reference<ConfigurableMutableResource>) { }
+
+    get uri(): URI {
+        return this.reference.object.uri;
+    }
+
+    get onDidChangeContents(): Event<void> {
+        return this.reference.object.onDidChangeContents;
+    }
+
+    dispose(): void {
+        this.reference.dispose();
+    }
+
+    readContents(): Promise<string> {
+        return this.reference.object.readContents();
+    }
+
+    saveContents(contents: string): Promise<void> {
+        return this.reference.object.saveContents(contents);
+    }
+
+    update(options: ResourceInitializationOptions): void {
+        this.reference.object.update(options);
+    }
+
+    get readOnly(): Resource['readOnly'] {
+        return this.reference.object.readOnly;
+    }
+
+    get initiallyDirty(): boolean {
+        return this.reference.object.initiallyDirty;
+    }
+
+    get autosaveable(): boolean {
+        return this.reference.object.autosaveable;
+    }
+}

package/src/common/index.ts

@@ -30,3 +30,5 @@ export * from './variable-service';
 export * from './settings-service';
 export * from './language-model-service';
 export * from './token-usage-service';
+export * from './ai-variable-resource';
+export * from './configurable-in-memory-resources';

package/src/common/prompt-service.ts

@@ -84,7 +84,7 @@ export interface PromptService {
      *
      * @param id the id of the prompt
      * @param args the object with placeholders, mapping the placeholder key to the value
-     * @param context the {@link AIVariableContext} to use during variable resolvement
+     * @param context the {@link AIVariableContext} to use during variable resolution
      * @param resolveVariable the variable resolving method. Fall back to using the {@link AIVariableService} if not given.
      */
     getPromptFragment(
@@ -202,9 +202,19 @@ export interface PromptCustomizationService {
     readonly onDidChangeCustomAgents: Event<void>;
 
     /**
-     * Open the custom agent yaml file.
+     * Returns all locations of existing customAgents.yml files and potential locations where
+     * new customAgents.yml files could be created.
+     *
+     * @returns An array of objects containing the URI and whether the file exists
+     */
+    getCustomAgentsLocations(): Promise<{ uri: URI, exists: boolean }[]>;
+
+    /**
+     * Opens an existing customAgents.yml file at the given URI, or creates a new one if it doesn't exist.
+     *
+     * @param uri The URI of the customAgents.yml file to open or create
      */
-    openCustomAgentYaml(): void;
+    openCustomAgentYaml(uri: URI): Promise<void>;
 }
 
 @injectable()
@@ -331,7 +341,7 @@ export class PromptServiceImpl implements PromptService {
      *
      * @param template the unresolved template text
      * @param args the object with placeholders, mapping the placeholder key to the value
-     * @param context the {@link AIVariableContext} to use during variable resolvement
+     * @param context the {@link AIVariableContext} to use during variable resolution
      * @param resolveVariable the variable resolving method. Fall back to using the {@link AIVariableService} if not given.
      */
     protected async getVariableAndArgReplacements(

package/src/common/prompt-variable-contribution.ts

@@ -13,7 +13,7 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
-import { CommandService, nls } from '@theia/core';
+import { CommandService, ILogger, nls } from '@theia/core';
 import { injectable, inject, optional } from '@theia/core/shared/inversify';
 import * as monaco from '@theia/monaco-editor-core';
 import {
@@ -50,6 +50,9 @@ export class PromptVariableContribution implements AIVariableContribution, AIVar
     @inject(PromptCustomizationService) @optional()
     protected readonly promptCustomizationService: PromptCustomizationService;
 
+    @inject(ILogger)
+    protected logger: ILogger;
+
     registerVariables(service: AIVariableService): void {
         service.registerResolver(PROMPT_VARIABLE, this);
         service.registerArgumentPicker(PROMPT_VARIABLE, this.triggerArgumentPicker.bind(this));
@@ -81,7 +84,12 @@ export class PromptVariableContribution implements AIVariableContribution, AIVar
                 }
             }
         }
-        return undefined;
+        this.logger.debug(`Could not resolve prompt variable '${request.variable.name}' with arg '${request.arg}'. Returning empty string.`);
+        return {
+            variable: request.variable,
+            value: '',
+            allResolvedDependencies: []
+        };
     }
 
     protected async triggerArgumentPicker(): Promise<string | undefined> {