loading

Author: curtisman

ts/packages/agentSdk/src/agentInterface.ts

@@ -48,10 +48,13 @@ export type SchemaTypeNames = {
 };
 
 export type SchemaFormat = "ts" | "pas";
+export type GrammarFormat = "ag";
+
 export type SchemaManifest = {
     description: string;
     schemaType: string | SchemaTypeNames; // string if there are only action schemas
     schemaFile: string | { format: SchemaFormat; content: string };
+    grammarFile?: string | { format: GrammarFormat; content: string };
     injected?: boolean; // whether the translator is injected into other domains, default is false
     cached?: boolean; // whether the translator's action should be cached, default is true
     streamingActions?: string[];

ts/packages/agentSdk/src/index.ts

@@ -4,6 +4,7 @@
 export {
     AppAgentManifest,
     ActionManifest,
+    GrammarFormat,
     SchemaFormat,
     SchemaManifest,
     AppAgent,

ts/packages/cache/src/cache/cache.ts

@@ -58,16 +58,24 @@ function getFailedResult(message: string): ProcessRequestActionResult {
         },
     };
 }
+
+export function getSchemaNamespaceKey(
+    name: string,
+    activityName: string | undefined,
+    schemaInfoProvider: SchemaInfoProvider | undefined,
+) {
+    return `${name},${schemaInfoProvider?.getActionSchemaFileHash(name) ?? ""},${activityName ?? ""}`;
+}
+
 // Namespace policy. Combines schema name, file hash, and activity name to indicate enabling/disabling of matching.
 export function getSchemaNamespaceKeys(
     schemaNames: string[],
     activityName: string | undefined,
     schemaInfoProvider: SchemaInfoProvider | undefined,
 ) {
     // Current namespace keys policy is just combining schema name its file hash
-    return schemaNames.map(
-        (name) =>
-            `${name},${schemaInfoProvider?.getActionSchemaFileHash(name) ?? ""},${activityName ?? ""}`,
+    return schemaNames.map((name) =>
+        getSchemaNamespaceKey(name, activityName, schemaInfoProvider),
     );
 }
 
@@ -99,7 +107,7 @@ export class AgentCache {
         cacheOptions?: CacheOptions,
         logger?: Telemetry.Logger,
     ) {
-        this._grammarStore = new GrammarStoreImpl();
+        this._grammarStore = new GrammarStoreImpl(schemaInfoProvider);
         this._constructionStore = new ConstructionStoreImpl(
             explainerName,
             cacheOptions,
@@ -129,7 +137,6 @@ export class AgentCache {
     public get grammarStore(): GrammarStore {
         return this._grammarStore;
     }
-
     public get constructionStore(): ConstructionStore {
         return this._constructionStore;
     }

ts/packages/cache/src/cache/types.ts

@@ -16,4 +16,5 @@ export type MatchResult = {
 
 export interface GrammarStore {
     addGrammar(namespace: string, grammar: any): void;
+    removeGrammar(namespace: string): void;
 }

ts/packages/cache/src/grammar/grammarStore.ts

@@ -4,11 +4,29 @@
 import { Grammar, matchGrammar } from "action-grammar";
 import { MatchOptions } from "../constructions/constructionCache.js";
 import { MatchResult, GrammarStore } from "../cache/types.js";
+import { getSchemaNamespaceKey } from "../cache/cache.js";
+import { SchemaInfoProvider } from "../explanation/schemaInfoProvider.js";
 
 export class GrammarStoreImpl implements GrammarStore {
     private readonly grammars: Map<string, any> = new Map();
-    public addGrammar(namespace: string, grammar: Grammar): void {
-        this.grammars.set(namespace, grammar);
+    public constructor(
+        private readonly schemaInfoProvider: SchemaInfoProvider | undefined,
+    ) {}
+    public addGrammar(schemaName: string, grammar: Grammar): void {
+        const namespaceKey = getSchemaNamespaceKey(
+            schemaName,
+            undefined,
+            this.schemaInfoProvider,
+        );
+        this.grammars.set(namespaceKey, grammar);
+    }
+    public removeGrammar(schemaName: string): void {
+        const namespaceKey = getSchemaNamespaceKey(
+            schemaName,
+            undefined,
+            this.schemaInfoProvider,
+        );
+        this.grammars.delete(namespaceKey);
     }
     public match(request: string, options?: MatchOptions): MatchResult[] {
         const namespaceKeys = options?.namespaceKeys;

ts/packages/dispatcher/package.json

@@ -47,6 +47,7 @@
     "@azure/identity": "^4.10.0",
     "@azure/msal-node-extensions": "^1.5.0",
     "@typeagent/agent-sdk": "workspace:*",
+    "action-grammar": "workspace:*",
     "action-schema": "workspace:*",
     "agent-cache": "workspace:*",
     "agent-rpc": "workspace:*",

ts/packages/dispatcher/src/context/appAgentManager.ts

@@ -32,6 +32,10 @@ import {
     AppAgentStateConfig,
     appAgentStateKeys,
 } from "./appAgentStateConfig.js";
+import { GrammarStore } from "../../../cache/dist/cache/types.js";
+import { getPackageFilePath } from "../utils/getPackageFilePath.js";
+import fs from "node:fs";
+import { Grammar, grammarFromJson } from "action-grammar";
 
 const debug = registerDebug("typeagent:dispatcher:agents");
 const debugError = registerDebug("typeagent:dispatcher:agents:error");
@@ -91,6 +95,32 @@ export const alwaysEnabledAgents = {
     commands: ["system"],
 };
 
+function loadGrammar(actionConfig: ActionConfig): Grammar | undefined {
+    if (actionConfig.grammarFile === undefined) {
+        return undefined;
+    }
+
+    let source: string;
+    if (typeof actionConfig.grammarFile === "string") {
+        const fullPath = getPackageFilePath(actionConfig.grammarFile);
+        source = fs.readFileSync(fullPath, "utf-8");
+        const isActionGrammar = actionConfig.grammarFile.endsWith(".ag.json");
+        if (!isActionGrammar) {
+            throw new Error(
+                `Unsupported grammar file extension: ${actionConfig.grammarFile}`,
+            );
+        }
+    } else {
+        if (actionConfig.grammarFile.format !== "ag") {
+            throw new Error(
+                `Unsupported grammar file extension: ${actionConfig.grammarFile}`,
+            );
+        }
+        source = actionConfig.grammarFile.content;
+    }
+    return grammarFromJson(JSON.parse(source));
+}
+
 export class AppAgentManager implements ActionConfigProvider {
     private readonly agents = new Map<string, AppAgentRecord>();
     private readonly actionConfigs = new Map<string, ActionConfig>();
@@ -237,6 +267,7 @@ export class AppAgentManager implements ActionConfigProvider {
 
     public async addProvider(
         provider: AppAgentProvider,
+        actionGrammarStore: GrammarStore | undefined,
         actionEmbeddingCache?: EmbeddingCache,
     ) {
         const semanticMapP: Promise<void>[] = [];
@@ -246,6 +277,8 @@ export class AppAgentManager implements ActionConfigProvider {
                 name,
                 manifest,
                 semanticMapP,
+
+                actionGrammarStore,
                 provider,
                 actionEmbeddingCache,
             );
@@ -259,6 +292,7 @@ export class AppAgentManager implements ActionConfigProvider {
         appAgentName: string,
         manifest: AppAgentManifest,
         semanticMapP: Promise<void>[],
+        actionGrammarStore: GrammarStore | undefined,
         provider?: AppAgentProvider,
         actionEmbeddingCache?: EmbeddingCache,
     ) {
@@ -289,6 +323,17 @@ export class AppAgentManager implements ActionConfigProvider {
                         ),
                     );
                 }
+
+                if (actionGrammarStore) {
+                    try {
+                        const g = loadGrammar(config);
+                        if (g) {
+                            actionGrammarStore.addGrammar(schemaName, g);
+                        }
+                    } catch {
+                        // REVIEW: Ignore errors for now.
+                    }
+                }
             } catch (e: any) {
                 schemaErrors.set(schemaName, e);
             }
@@ -321,6 +366,7 @@ export class AppAgentManager implements ActionConfigProvider {
         appAgentName: string,
         manifest: AppAgentManifest,
         appAgent: AppAgent,
+        actionGrammarStore?: GrammarStore,
     ) {
         if (this.agents.has(appAgentName)) {
             throw new Error(`App agent '${appAgentName}' already exists`);
@@ -332,6 +378,7 @@ export class AppAgentManager implements ActionConfigProvider {
             appAgentName,
             manifest,
             semanticMapP,
+            actionGrammarStore,
         );
         record.appAgent = appAgent;
 
@@ -340,7 +387,7 @@ export class AppAgentManager implements ActionConfigProvider {
         debug("Finish action embeddings");
     }
 
-    private cleanupAgent(appAgentName: string) {
+    private cleanupAgent(appAgentName: string, grammarStore?: GrammarStore) {
         for (const [schemaName, config] of this.actionConfigs) {
             if (getAppAgentName(schemaName) !== appAgentName) {
                 continue;
@@ -351,13 +398,19 @@ export class AppAgentManager implements ActionConfigProvider {
             if (config.transient) {
                 delete this.transientAgents[schemaName];
             }
+            if (grammarStore) {
+                grammarStore.removeGrammar(schemaName);
+            }
         }
     }
 
-    public async removeAgent(appAgentName: string) {
+    public async removeAgent(
+        appAgentName: string,
+        grammarStore?: GrammarStore,
+    ) {
         const record = this.getRecord(appAgentName);
         this.agents.delete(appAgentName);
-        this.cleanupAgent(appAgentName);
+        this.cleanupAgent(appAgentName, grammarStore);
 
         await this.closeSessionContext(record);
         if (record.appAgent !== undefined) {

ts/packages/dispatcher/src/context/commandHandlerContext.ts

@@ -319,11 +319,19 @@ async function addAppAgentProviders(
         }
 
         const inlineAppProvider = createBuiltinAppAgentProvider(context);
-        await context.agents.addProvider(inlineAppProvider, embeddingCache);
+        await context.agents.addProvider(
+            inlineAppProvider,
+            context.agentCache.grammarStore,
+            embeddingCache,
+        );
 
         if (appAgentProviders) {
             for (const provider of appAgentProviders) {
-                await context.agents.addProvider(provider, embeddingCache);
+                await context.agents.addProvider(
+                    provider,
+                    context.agentCache.grammarStore,
+                    embeddingCache,
+                );
             }
         }
         if (embeddingCachePath) {
@@ -361,7 +369,7 @@ export async function installAppProvider(
     provider: AppAgentProvider,
 ) {
     // Don't use embedding cache for a new agent.
-    await context.agents.addProvider(provider);
+    await context.agents.addProvider(provider, context.agentCache.grammarStore);
 
     await setAppAgentStates(context);
 

ts/packages/dispatcher/src/context/system/handlers/installCommandHandlers.ts

@@ -82,7 +82,10 @@ export class UninstallCommandHandler implements CommandHandler {
         const name = params.args.name;
         installer.uninstall(name);
 
-        await systemContext.agents.removeAgent(name);
+        await systemContext.agents.removeAgent(
+            name,
+            systemContext.agentCache.grammarStore,
+        );
 
         displayResult(`Agent '${name}' uninstalled.`, context);
     }

ts/packages/dispatcher/src/execute/sessionContext.ts

@@ -61,7 +61,10 @@ export function createSessionContext<T = unknown>(
                           `Permission denied: dynamic agent '${agentName}' not added by this agent`,
                       );
                   }
-                  return context.agents.removeAgent(agentName);
+                  return context.agents.removeAgent(
+                      agentName,
+                      context.agentCache.grammarStore,
+                  );
               })
         : () => {
               throw new Error("Permission denied: cannot remove dynamic agent");