Scope

export class Scope extends ScopeEntry {
  readonly id: string;
  readonly logger: FrontMcpLogger;
  readonly entryPath: string;
  readonly routeBase: string;
  readonly ready: Promise<void>;
  readonly metadata: ScopeMetadata;
}

type ScopeMetadata = AppScopeMetadata | MultiAppScopeMetadata;

get tools(): ToolRegistry

const tools = scope.tools.getTools();
const tool = scope.tools.findByName('my_tool');

get resources(): ResourceRegistry

const resources = scope.resources.getResources();
const templates = scope.resources.getResourceTemplates();
const resource = scope.resources.findResourceForUri('config://app');

get prompts(): PromptRegistry

const prompts = scope.prompts.getPrompts();
const prompt = scope.prompts.findByName('research');

get agents(): AgentRegistry

const agents = scope.agents.getAgents();
const agent = scope.agents.findByName('research-agent');

get skills(): SkillRegistry

const skills = scope.skills.getSkills();
const searchResults = await scope.skills.search('code review', { topK: 5 });

get providers(): ProviderRegistry

const service = scope.providers.get(ServiceToken);

get auth(): FrontMcpAuth

get authProviders(): AuthRegistry

get apps(): AppRegistry

get hooks(): HookRegistryInterface

get plugins(): PluginRegistry | undefined

get notifications(): NotificationService

scope.notifications.on('tool-called', (event) => {
  console.log('Tool called:', event.toolName);
});

get elicitationStore(): ElicitationStore

get eventStore(): EventStore | undefined

get skillSession(): SkillSessionManager | undefined

get toolUI(): ToolUIRegistry

runFlow<Name extends FlowName>(
  name: Name,
  input: FlowInputOf<Name>,
  deps?: Map<Token, Type>
): Promise<FlowOutputOf<Name> | undefined>

const result = await scope.runFlow('tools:call-tool', {
  request: {
    method: 'tools/call',
    params: { name: 'my_tool', arguments: { input: 'test' } },
  },
  ctx: { authInfo },
});

runFlowForOutput<Name extends FlowName>(
  name: Name,
  input: FlowInputOf<Name>,
  deps?: Map<Token, Type>
): Promise<FlowOutputOf<Name>>

registryFlows(...flows: FlowType[]): Promise<void>

@Tool({ name: 'my_tool', inputSchema: {} })
class MyTool extends ToolContext {
  async execute() {
    // Access scope
    const tools = this.scope.tools;
    const resources = this.scope.resources;

    // List other tools
    const allTools = tools.getTools();

    return { toolCount: allTools.length };
  }
}

const instance = await FrontMcpInstance.createForGraph(config);
const scopes = instance.getScopes();

const scope = scopes[0];
console.log('Tools:', scope.tools.getTools().length);

const client = await connect(config);
const tools = await client.listTools(); // Uses scope.tools internally

const instance = await FrontMcpInstance.createForGraph(config);
const [scope] = instance.getScopes();

// List all tools
scope.tools.getTools().forEach(tool => {
  console.log(`Tool: ${tool.name}`);
  console.log(`  Description: ${tool.description}`);
  console.log(`  Input: ${JSON.stringify(tool.inputSchema)}`);
});

// List all resources
scope.resources.getResources().forEach(resource => {
  console.log(`Resource: ${resource.name} - ${resource.uri}`);
});

// List all skills
scope.skills.getSkills().forEach(skill => {
  console.log(`Skill: ${skill.name}`);
  console.log(`  Tools: ${skill.tools.map(t => t.name).join(', ')}`);
});

const scope = instance.getScopes()[0];

// Subscribe to tool changes
scope.tools.subscribe({}, (event) => {
  console.log(`Tool ${event.kind}:`, event);
});

// Subscribe to notifications
scope.notifications.on('progress', (event) => {
  console.log(`Progress: ${event.progress}/${event.total}`);
});

const scope = instance.getScopes()[0];

if (scope.skillSession) {
  // Get allowed tools for a session
  const allowed = await scope.skillSession.getAllowedTools(sessionId);

  // Check if tool is allowed
  const canUse = await scope.skillSession.isToolAllowed(sessionId, 'my_tool');
}