@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/src/config/validate-providers.test.ts

@@ -1,148 +0,0 @@
-import type { AIProvider, AIProviderRegistry } from '@genesislcap/foundation-ai';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import type { AgentConfig } from './config';
-import { resolveChatProvider, validateStaticAgentProviders } from './validate-providers';
-
-const chatProvider = (): AIProvider => ({
-  chat: async () => ({ role: 'assistant', content: '' }),
-});
-
-const promptOnlyProvider = (): AIProvider => ({
-  prompt: async () => '',
-});
-
-/**
- * Minimal in-test registry — implements only what the validation helpers
- * touch (`get`, `names`). Avoids depending on foundation-ai's concrete
- * registry impl, and keeps these tests Node-runnable.
- */
-const makeRegistry = (providers: Record<string, AIProvider>): AIProviderRegistry => {
-  const map = new Map(Object.entries(providers));
-  return {
-    get: (name) => map.get(name),
-    default: () => map.values().next().value as AIProvider,
-    defaultName: () => map.keys().next().value as string,
-    names: () => [...map.keys()],
-    getStatus: async () => null,
-    listStatuses: async () => [],
-  };
-};
-
-const specialist = (overrides: Partial<AgentConfig> & { name: string }): AgentConfig =>
-  ({
-    name: overrides.name,
-    description: 'test specialist',
-    ...overrides,
-  }) as AgentConfig;
-
-// ---------------------------------------------------------------------------
-// resolveChatProvider
-// ---------------------------------------------------------------------------
-
-const resolve = createLogicSuite('resolveChatProvider');
-
-resolve('returns the provider when the name is registered and has chat()', () => {
-  const fast = chatProvider();
-  const registry = makeRegistry({ fast });
-  assert.is(resolveChatProvider(registry, 'fast', 'A'), fast);
-});
-
-resolve('throws on an unknown provider name with the agent name in the message', () => {
-  const registry = makeRegistry({ fast: chatProvider() });
-  assert.throws(
-    () => resolveChatProvider(registry, 'deep', 'A'),
-    /Agent "A" references unknown provider "deep"/,
-  );
-});
-
-resolve('throws including the registered names so the misconfiguration is debuggable', () => {
-  const registry = makeRegistry({
-    fast: chatProvider(),
-    deep: chatProvider(),
-    cheap: chatProvider(),
-  });
-  assert.throws(() => resolveChatProvider(registry, 'typo', 'A'), /Registered: fast, deep, cheap/);
-});
-
-resolve('throws when the resolved provider does not implement chat()', () => {
-  const registry = makeRegistry({ chrome: promptOnlyProvider() });
-  assert.throws(
-    () => resolveChatProvider(registry, 'chrome', 'A'),
-    /Agent "A" resolved to provider "chrome" which does not implement chat\(\)/,
-  );
-});
-
-resolve.run();
-
-// ---------------------------------------------------------------------------
-// validateStaticAgentProviders
-// ---------------------------------------------------------------------------
-
-const validate = createLogicSuite('validateStaticAgentProviders');
-
-validate('accepts agents with no `provider` field (back-compat path)', () => {
-  const registry = makeRegistry({ default: chatProvider() });
-  assert.not.throws(() => validateStaticAgentProviders([specialist({ name: 'A' })], registry));
-});
-
-validate('accepts agents that name a registered chat-capable provider', () => {
-  const registry = makeRegistry({ fast: chatProvider(), deep: chatProvider() });
-  assert.not.throws(() =>
-    validateStaticAgentProviders([specialist({ name: 'A', provider: 'deep' })], registry),
-  );
-});
-
-validate('throws when a top-level agent references an unknown provider', () => {
-  const registry = makeRegistry({ fast: chatProvider() });
-  assert.throws(
-    () => validateStaticAgentProviders([specialist({ name: 'A', provider: 'deep' })], registry),
-    /Agent "A" references unknown provider "deep"/,
-  );
-});
-
-validate('recurses into subAgents — bad provider on a sub-agent throws', () => {
-  const registry = makeRegistry({ fast: chatProvider() });
-  const sub = specialist({ name: 'Sub', provider: 'missing' });
-  assert.throws(
-    () => validateStaticAgentProviders([specialist({ name: 'A', subAgents: [sub] })], registry),
-    /Agent "Sub" references unknown provider "missing"/,
-  );
-});
-
-validate(
-  'recurses through multiple levels — bad provider on a deeply-nested sub-agent throws',
-  () => {
-    const registry = makeRegistry({ fast: chatProvider() });
-    const deepest = specialist({ name: 'Deepest', provider: 'missing' });
-    const middle = specialist({ name: 'Middle', subAgents: [deepest] });
-    assert.throws(
-      () =>
-        validateStaticAgentProviders([specialist({ name: 'Top', subAgents: [middle] })], registry),
-      /Agent "Deepest" references unknown provider "missing"/,
-    );
-  },
-);
-
-validate('defers function-form `provider` — it is not invoked at validation time', () => {
-  const registry = makeRegistry({ fast: chatProvider() });
-  const agent = specialist({
-    name: 'A',
-    // If validateStaticAgentProviders eagerly resolved this, it would throw
-    // here. The contract is that function-form is deferred to the driver's
-    // per-turn resolver.
-    provider: () => {
-      throw new Error('function-form provider should not be invoked at validation time');
-    },
-  });
-  assert.not.throws(() => validateStaticAgentProviders([agent], registry));
-});
-
-validate('shared sub-agent across two parents validates cleanly', () => {
-  const registry = makeRegistry({ fast: chatProvider() });
-  const shared = specialist({ name: 'Shared', provider: 'fast' });
-  const parentA = specialist({ name: 'ParentA', subAgents: [shared] });
-  const parentB = specialist({ name: 'ParentB', subAgents: [shared] });
-  assert.not.throws(() => validateStaticAgentProviders([parentA, parentB], registry));
-});
-
-validate.run();

package/src/config/validate-providers.ts

@@ -1,58 +0,0 @@
-import type { AIProvider, AIProviderRegistry } from '@genesislcap/foundation-ai';
-import type { AgentConfig } from './config';
-
-/**
- * Resolve a provider name against the registry and assert it implements
- * `chat()` — the capability the chat tool-loop depends on. Throws with a
- * message naming the agent so misconfigured agents are easy to track down.
- *
- * Used by both the up-front static walk in `OrchestratingDriver` and by
- * `ChatDriver`'s per-turn resolver for function-form `provider` values.
- *
- * @internal
- */
-export function resolveChatProvider(
-  registry: AIProviderRegistry,
-  providerName: string,
-  agentName: string,
-): AIProvider {
-  const provider = registry.get(providerName);
-  if (!provider) {
-    const available = registry.names().join(', ') || '(none)';
-    throw new Error(
-      `Agent "${agentName}" references unknown provider "${providerName}". Registered: ${available}`,
-    );
-  }
-  if (!provider.chat) {
-    throw new Error(
-      `Agent "${agentName}" resolved to provider "${providerName}" which does not implement chat().`,
-    );
-  }
-  return provider;
-}
-
-/**
- * Walk an agent tree (including nested `subAgents`) and validate every static
- * `provider: string` against the registry. Function-form `provider` values are
- * deferred — they validate on first resolution inside the driver.
- *
- * Throws on the first failure, with the same message shape produced by
- * {@link resolveChatProvider}.
- *
- * @internal
- */
-export function validateStaticAgentProviders(
-  agents: AgentConfig[],
-  registry: AIProviderRegistry,
-): void {
-  const visited = new Set<AgentConfig>();
-  const walk = (agent: AgentConfig): void => {
-    if (visited.has(agent)) return;
-    visited.add(agent);
-    if (typeof agent.provider === 'string') {
-      resolveChatProvider(registry, agent.provider, agent.name);
-    }
-    for (const sub of agent.subAgents ?? []) walk(sub);
-  };
-  for (const root of agents) walk(root);
-}

package/src/index.ts

@@ -1,29 +0,0 @@
-export * from './main/main';
-export * from './main/main.types';
-export * from './main/main.template';
-export * from './components/agent-picker';
-export * from './components/ai-driver';
-export * from './components/chat-driver';
-export type {
-  InteractionCompletedEventDetail,
-  InteractionCostEventDetail,
-} from './components/chat-interaction-wrapper/chat-interaction-wrapper';
-export * from './components/orchestrating-driver';
-export * from './components/popout-manager';
-export * from './channel/ai-activity-channel';
-export * from './channel/ai-activity-bus';
-export * from './config/config';
-export * from './config/define-stateful-agent';
-export * from './config/fallback-agents';
-export * from './state/persistence';
-export * from './provider/ai-provider-switcher';
-export * from './provider/assistant-app-settings';
-export * from './utils/tool-fold';
-export { assistantSettingsSectionTitleStyles } from './styles/settings-section';
-export type { TurnFailureReason } from './state/debug-event-log';
-export type { TimelineMessage } from './utils/flatten-sub-agent-messages';
-export type { CostSessionModelEntry, CostSessionRecord } from './utils/cost-session-history';
-export type { ModelTagAppearance } from '@genesislcap/foundation-ai';
-export type { AiChatInteraction, AiChatWidget } from './types/ai-chat-widget';
-export type { InteractionContext } from './types/interaction-context';
-export { AiChatMarkdown } from './components/chat-markdown/chat-markdown';