@genesislcap/ai-assistant 14.409.0-FUI-2495.2 → 14.409.1

package/src/components/orchestrating-driver/orchestrating-driver.ts

@@ -1,300 +0,0 @@
-import type {
-  AIProvider,
-  ChatAttachment,
-  ChatDriverResult,
-  ChatMessage,
-  ChatRequestOptions,
-} from '@genesislcap/foundation-ai';
-import type { AgentConfig, FallbackAgentConfig, SpecialistAgentConfig } from '../../config/config';
-import { logger } from '../../utils/logger';
-import type { AiDriver } from '../ai-driver/ai-driver';
-import { ChatDriver, REQUEST_CONTINUATION_TOOL } from '../chat-driver/chat-driver';
-
-const DEFAULT_MAX_HANDOFFS = 3;
-const DEFAULT_CLASSIFIER_HISTORY_LENGTH = 4;
-const DEFAULT_CLASSIFIER_RETRIES = 2;
-
-const REQUEST_CONTINUATION_DEFINITION = {
-  name: REQUEST_CONTINUATION_TOOL,
-  description:
-    "Call this when you have completed your part of the task but fulfilling the user's full request requires capabilities outside your domain. Do not call this if you can complete the request yourself. Pass a plain-language description of what still needs to be done — another specialist will be selected automatically.",
-  parameters: {
-    type: 'object',
-    required: ['summary', 'remaining_task'],
-    properties: {
-      summary: {
-        type: 'string',
-        description: 'What you found or did — passed as context to the next specialist.',
-      },
-      remaining_task: {
-        type: 'string',
-        description:
-          'What still needs to be done, in plain language. Used to route to the right specialist.',
-      },
-    },
-  },
-};
-
-function isSpecialist(agent: AgentConfig): agent is SpecialistAgentConfig {
-  return !agent.fallback;
-}
-
-function isFallback(agent: AgentConfig): agent is FallbackAgentConfig {
-  return agent.fallback === true;
-}
-
-function buildFallbackSystemPrompt(
-  fallback: FallbackAgentConfig,
-  specialists: SpecialistAgentConfig[],
-): string {
-  const agentList = specialists.map((s) => `- ${s.name}: ${s.description}`).join('\n');
-  if (fallback.systemPrompt) {
-    return fallback.systemPrompt.replace('{{agents}}', agentList);
-  }
-  return `You are a helpful assistant. You cannot directly help with the user's request, but the following specialists are available:\n\n${agentList}\n\nPolitely let the user know what you can help with and invite them to rephrase their request.`;
-}
-
-/**
- * Prepares the history for a given agent by masking tool call args and results
- * produced by other agents — preserving conversation structure without leaking
- * irrelevant domain data into the active agent's context.
- */
-function transformHistoryForAgent(history: ChatMessage[], agentName: string): ChatMessage[] {
-  return history.map((msg) => {
-    if (!msg.agentName || msg.agentName === agentName) return msg;
-    if (msg.toolCalls?.length) {
-      return { ...msg, toolCalls: msg.toolCalls.map((tc) => ({ ...tc, args: {} })) };
-    }
-    if (msg.toolResult) {
-      return { ...msg, content: "[other agent's tool result omitted]" };
-    }
-    return msg;
-  });
-}
-
-/**
- * Orchestrates multiple specialist agents. Sits between `FoundationAiAssistant`
- * and `ChatDriver`, classifying each user message and routing it to the right
- * specialist — each with its own focused system prompt, tools, and primer.
- *
- * @beta
- */
-export class OrchestratingDriver extends EventTarget implements AiDriver {
-  private readonly chatDriver: ChatDriver;
-  private readonly specialists: SpecialistAgentConfig[];
-  private readonly fallback?: FallbackAgentConfig;
-  private readonly maxHandoffs: number;
-  private readonly classifierHistoryLength: number;
-  private readonly classifierRetries: number;
-
-  activeAgent?: AgentConfig;
-
-  constructor(
-    private readonly aiProvider: AIProvider,
-    private readonly agents: AgentConfig[],
-    options: {
-      maxHandoffs?: number;
-      classifierHistoryLength?: number;
-      classifierRetries?: number;
-      maxToolIterations?: number;
-    } = {},
-  ) {
-    super();
-    this.maxHandoffs = options.maxHandoffs ?? DEFAULT_MAX_HANDOFFS;
-    this.classifierHistoryLength =
-      options.classifierHistoryLength ?? DEFAULT_CLASSIFIER_HISTORY_LENGTH;
-    this.classifierRetries = options.classifierRetries ?? DEFAULT_CLASSIFIER_RETRIES;
-
-    this.specialists = agents.filter(isSpecialist);
-    const fallbacks = agents.filter(isFallback);
-    if (fallbacks.length > 1) {
-      logger.warn(
-        'OrchestratingDriver: multiple fallback agents found — only the first will be used.',
-      );
-    }
-
-    const rawFallback = fallbacks[0];
-    this.fallback = rawFallback
-      ? { ...rawFallback, systemPrompt: buildFallbackSystemPrompt(rawFallback, this.specialists) }
-      : undefined;
-
-    this.chatDriver = new ChatDriver(
-      aiProvider,
-      {},
-      [],
-      undefined,
-      undefined,
-      options.maxToolIterations,
-    );
-
-    // Proxy history-updated events from the shared driver
-    this.chatDriver.addEventListener('history-updated', (e: Event) => {
-      this.dispatchEvent(new CustomEvent('history-updated', { detail: (e as CustomEvent).detail }));
-    });
-  }
-
-  resolveInteraction(interactionId: string, result: unknown): void {
-    this.chatDriver.resolveInteraction(interactionId, result);
-  }
-
-  loadHistory(messages: ChatMessage[]): void {
-    this.chatDriver.loadHistory(messages);
-  }
-
-  getRawHistory(): readonly ChatMessage[] {
-    return this.chatDriver.getHistory();
-  }
-
-  async sendMessage(input: string, attachments?: ChatAttachment[]): Promise<ChatDriverResult> {
-    const history = this.chatDriver.getHistory() as ChatMessage[];
-    this.dispatchEvent(new CustomEvent('orchestrating-start'));
-    let currentAgent = await this.classify(input, history);
-    let isHandoff = false;
-    let handoffs = 0;
-    let handoffSummary = '';
-    let remainingTask = '';
-
-    while (true) {
-      this.applyAgent(currentAgent);
-
-      let result: ChatDriverResult;
-      if (isHandoff) {
-        const contextPrimer: ChatMessage[] = handoffSummary
-          ? [{ role: 'user', content: `[Context from previous agent]: ${handoffSummary}` }]
-          : [];
-        // eslint-disable-next-line no-await-in-loop
-        result = await this.chatDriver.continueFromHistory(contextPrimer);
-      } else {
-        // eslint-disable-next-line no-await-in-loop
-        result = await this.chatDriver.sendMessage(input, attachments);
-      }
-
-      if (result.reason !== 'agent-handoff' || isFallback(currentAgent)) {
-        break;
-      }
-
-      handoffs += 1;
-      if (handoffs > this.maxHandoffs) {
-        this.appendInlineMessage(
-          `I wasn't able to fully complete your request — the task required more hand-offs between specialists than allowed (max: ${this.maxHandoffs}). Please try breaking your request into smaller steps.`,
-        );
-        break;
-      }
-
-      handoffSummary = result.summary;
-      remainingTask = result.remainingTask;
-      isHandoff = true;
-
-      const updatedHistory = this.chatDriver.getHistory() as ChatMessage[];
-      this.dispatchEvent(new CustomEvent('orchestrating-start'));
-      // eslint-disable-next-line no-await-in-loop
-      currentAgent = await this.classify(remainingTask, updatedHistory);
-    }
-
-    return { reason: 'done' };
-  }
-
-  async continueFromHistory(transientPrimer?: ChatMessage[]): Promise<ChatDriverResult> {
-    return this.chatDriver.continueFromHistory(transientPrimer);
-  }
-
-  private applyAgent(agent: AgentConfig): void {
-    // Fallback agents are terminal and should not hand off to other specialists
-    const agentToApply = isFallback(agent)
-      ? agent
-      : {
-          ...agent,
-          toolDefinitions: [...(agent.toolDefinitions ?? []), REQUEST_CONTINUATION_DEFINITION],
-        };
-
-    // Mask history from other agents before handing context to this specialist
-    const rawHistory = this.chatDriver.getHistory() as ChatMessage[];
-    const maskedHistory = transformHistoryForAgent(rawHistory, agent.name);
-
-    // Inject an agent switch indicator when the active specialist changes
-    const previousAgent = this.activeAgent;
-    if (previousAgent && previousAgent.name !== agent.name) {
-      maskedHistory.push({ role: 'system-event', content: agent.name });
-    }
-
-    this.chatDriver.loadHistory(maskedHistory);
-    this.chatDriver.applyAgent(agentToApply);
-    this.activeAgent = agent;
-    this.dispatchEvent(new CustomEvent('orchestrating-stop'));
-    this.dispatchEvent(new CustomEvent('agent-changed', { detail: agent }));
-  }
-
-  private async classify(input: string, history: ChatMessage[]): Promise<AgentConfig> {
-    if (this.specialists.length === 0) {
-      return this.fallback ?? { name: 'Assistant', fallback: true };
-    }
-
-    const agentList = this.specialists
-      .map((a, i) => `${i}: ${a.name} — ${a.description}`)
-      .join('\n');
-
-    const recentMessages = history
-      .filter((m) => m.role === 'user' || m.role === 'assistant')
-      .slice(-this.classifierHistoryLength)
-      .map((m) => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`)
-      .join('\n');
-
-    const classifierPrompt = `You are a routing classifier. Call select_agent with the index of the best matching agent for the user message. Use -1 only if the request is entirely unrelated to every agent listed — prefer the closest match when in doubt. If the request spans multiple agents, pick the one that should act first; I will re-classify and route again once that agent is done.\n\nAgents:\n${agentList}${recentMessages ? `\n\nRecent conversation:\n${recentMessages}` : ''}`;
-
-    const routingTool = {
-      name: 'select_agent',
-      description: 'Select the most appropriate agent for the user message.',
-      parameters: {
-        type: 'object',
-        required: ['agent_index'],
-        properties: {
-          agent_index: {
-            type: 'integer',
-            description: 'Zero-based index of the matching agent, or -1 if no agent matches.',
-          },
-        },
-      },
-    };
-
-    for (let attempt = 0; attempt <= this.classifierRetries; attempt += 1) {
-      try {
-        const options: ChatRequestOptions = {
-          systemPrompt: classifierPrompt,
-          tools: [routingTool],
-        };
-        // eslint-disable-next-line no-await-in-loop
-        const response = await this.aiProvider.chat!([], input, options);
-        const tc = response.toolCalls?.[0];
-        const index = tc?.name === 'select_agent' ? (tc.args.agent_index as number) : -1;
-
-        if (index >= 0 && index < this.specialists.length) {
-          return this.specialists[index];
-        }
-        // index === -1 — fall through to fallback
-        break;
-      } catch (e) {
-        logger.warn(`OrchestratingDriver: classifier attempt ${attempt + 1} failed:`, e);
-        if (attempt === this.classifierRetries) {
-          logger.error('OrchestratingDriver: classifier failed after all retries, using fallback');
-        }
-      }
-    }
-
-    if (this.fallback) return this.fallback;
-
-    // No fallback configured — emit an inline response and return first specialist as no-op
-    const specialistNames = this.specialists.map((s) => s.name).join(', ');
-    this.appendInlineMessage(
-      `I'm not sure how to help with that. I can assist with: ${specialistNames}.`,
-    );
-    return this.specialists[0];
-  }
-
-  private appendInlineMessage(content: string): void {
-    const history = this.chatDriver.getHistory() as ChatMessage[];
-    this.chatDriver.loadHistory([...history, { role: 'assistant', content }]);
-    this.dispatchEvent(
-      new CustomEvent('history-updated', { detail: this.chatDriver.getHistory() }),
-    );
-  }
-}

package/src/components/popout-manager/index.ts

@@ -1 +0,0 @@
-export * from './popout-manager';

package/src/components/popout-manager/popout-manager.ts

@@ -1,144 +0,0 @@
-import { customElement, GenesisElement, html, observable } from '@genesislcap/web-core';
-import { agenticActivityBus } from '../../channel/ai-activity-bus';
-import type { AiAssistantSerializedState } from '../../channel/ai-activity-channel';
-
-/**
- * Contract for pages that support docking the AI assistant.
- * Register an implementation with {@link getAiPopoutManager} on mount and deregister on unmount.
- *
- * @beta
- */
-export interface AiDockProvider {
-  /**
-   * Called when the user expands the bubble. Receives the assistant element and the
-   * serialized state to restore. The provider is responsible for inserting the element
-   * into its layout and calling `applyState` once the element is connected.
-   * Resolves when the element is connected and state has been applied.
-   */
-  onDock(element: HTMLElement, state: AiAssistantSerializedState | undefined): Promise<void>;
-  /** Called when the user collapses the panel or before navigation. */
-  onUndock(): Promise<void>;
-  /**
-   * Called by `collapseIfDocked` before navigation. The provider is responsible for
-   * finding the docked assistant element and calling `handlePopout()` on it, which
-   * publishes `chat-popin` and returns the assistant to the bubble.
-   */
-  initiateCollapse(): void;
-}
-
-/**
- * App-shell component that owns the pop-out/pop-in lifecycle for the AI assistant bubble.
- *
- * @remarks
- * Place this in the persistent app shell, wrapping a `foundation-ai-chat-bubble` that
- * contains an AI assistant element in the `dialog-content` slot. The component will
- * auto-create a matching collapse-mode element for docking into pages, and will
- * control the expand button visibility based on whether a dock provider is registered.
- *
- * Pages that support docking call `aiPopoutManager.registerDockProvider()` on mount
- * and `aiPopoutManager.deregisterDockProvider()` on unmount.
- *
- * @example
- * ```html
- * <foundation-ai-popout-manager>
- *   <foundation-ai-chat-bubble title="My Assistant">
- *     <my-assistant slot="dialog-content"></my-assistant>
- *   </foundation-ai-chat-bubble>
- * </foundation-ai-popout-manager>
- * ```
- *
- * @beta
- */
-@customElement({
-  name: 'foundation-ai-popout-manager',
-  template: html`
-    <slot></slot>
-  `,
-})
-export class FoundationAiPopoutManager extends GenesisElement {
-  /** True when a dock provider is registered — controls expand button visibility. */
-  @observable canDock = false;
-
-  private collapseEl: HTMLElement | null = null;
-  private dockProvider: AiDockProvider | null = null;
-  private isDocked = false;
-  private unsubBus?: () => void;
-
-  connectedCallback() {
-    super.connectedCallback();
-    _aiPopoutManager = this;
-
-    const bubble = this.querySelector('foundation-ai-chat-bubble');
-    const assistantEl = bubble?.querySelector('[slot="dialog-content"]');
-    if (assistantEl) {
-      this.collapseEl = document.createElement(assistantEl.tagName.toLowerCase());
-      this.collapseEl.setAttribute('popout-mode', 'collapse');
-    }
-
-    const unsubPopout = agenticActivityBus.subscribe('chat-popout', async ({ state }) => {
-      if (this.isDocked || !this.dockProvider || !this.collapseEl) return;
-      this.isDocked = true;
-      await this.dockProvider.onDock(this.collapseEl, state);
-    });
-
-    const unsubPopin = agenticActivityBus.subscribe('chat-popin', () => {
-      this.isDocked = false;
-      this.dockProvider?.onUndock();
-    });
-
-    this.unsubBus = () => {
-      unsubPopout();
-      unsubPopin();
-    };
-  }
-
-  disconnectedCallback() {
-    super.disconnectedCallback();
-    this.unsubBus?.();
-    this.unsubBus = undefined;
-    _aiPopoutManager = undefined;
-  }
-
-  canDockChanged() {
-    const bubble = this.querySelector('foundation-ai-chat-bubble');
-    const assistantEl = bubble?.querySelector('[slot="dialog-content"]');
-    if (this.canDock) {
-      assistantEl?.setAttribute('popout-mode', 'expand');
-    } else {
-      assistantEl?.removeAttribute('popout-mode');
-    }
-  }
-
-  registerDockProvider(provider: AiDockProvider): void {
-    this.dockProvider = provider;
-    this.canDock = true;
-  }
-
-  deregisterDockProvider(): void {
-    this.isDocked = false;
-    this.dockProvider = null;
-    this.canDock = false;
-  }
-
-  /**
-   * If the assistant is currently docked, collapses it back into the bubble.
-   * Await this in `onBeforeNavButtonClick` to ensure cleanup before navigation.
-   */
-  collapseIfDocked(): Promise<void> {
-    if (!this.isDocked || !this.dockProvider) return Promise.resolve();
-    this.dockProvider.initiateCollapse();
-    return Promise.resolve();
-  }
-}
-
-let _aiPopoutManager: FoundationAiPopoutManager | undefined;
-
-/**
- * Returns the active `FoundationAiPopoutManager` instance, or `undefined` if none is mounted.
- * Import this in pages to call `registerDockProvider` / `deregisterDockProvider`.
- *
- * @beta
- */
-export function getAiPopoutManager(): FoundationAiPopoutManager | undefined {
-  return _aiPopoutManager;
-}

package/src/config/fallback-agents.ts

@@ -1,29 +0,0 @@
-import type { FallbackAgentConfig } from './config';
-
-/**
- * A warm, conversational fallback agent. Acknowledges it can't help directly,
- * explains what the available specialists can do, and invites the user to retry.
- *
- * The system prompt is generated at runtime by `OrchestratingDriver` from the
- * specialist list — no manual authoring required.
- *
- * @beta
- */
-export const friendlyFallbackAgent: FallbackAgentConfig = {
-  name: 'Assistant',
-  fallback: true,
-  systemPrompt: `You are a warm, friendly assistant. For general conversation like "Hi" or "How are you", you can have a friendly chat. For anything more complex, you cannot directly help, but you can explain what specialists are available. The available specialists are:\n\n{{agents}}\n\nPolitely let the user know what you can help with and invite them to rephrase their request if it is outside your scope.`,
-};
-
-/**
- * A brief, professional fallback agent. States what is available without
- * elaboration. The `{{agents}}` placeholder is replaced at runtime by
- * `OrchestratingDriver` with the generated specialist list.
- *
- * @beta
- */
-export const strictFallbackAgent: FallbackAgentConfig = {
-  name: 'Assistant',
-  fallback: true,
-  systemPrompt: `You are a concise assistant. The user's request is outside your scope. Respond with a single short sentence stating what you can assist with. Do not elaborate. The available specialists are: {{agents}}.`,
-};