@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/dist/esm/components/settings-modal/settings-modal.template.test.js

@@ -1,91 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { FoundationAiAssistant } from '../../main/main';
-import { getSessionStore, clearAllSessionStores } from '../../state/session-store';
-import { settingsUsageMetersTemplate } from './settings-modal.template';
-// Hold a reference so the custom-element registration isn't tree-shaken.
-FoundationAiAssistant;
-// GENC-1464 — the shared meter column in the settings modal's "AI Model
-// Settings" section.
-//
-// The section body is a 4-unit flex column and the budget meter is a 2-unit
-// one, so an unwrapped context indicator sat 4 units above the first vendor row
-// while the vendor rows sat 2 apart — three visually identical meter rows
-// reading as an uneven 4/2/2. Both meters now share ONE 2-unit column
-// (`.settings-usage-meters`, grouped with `.settings-budget-usage` in the
-// styles — see settings-modal.styles.test.ts for the gap itself).
-//
-// The wrapper must also be ABSENT when neither meter shows: a permanent wrapper
-// is a permanent flex child of the section body, so a host with no meters would
-// pay a stray 4-unit gap after its model slot for a div that renders nothing.
-// That is a structural claim about the template, so this suite renders the
-// template rather than reading a getter — the getter cannot show whether the
-// `when` was wired to it.
-//
-// The element is created but never CONNECTED (`document.createElement` upgrades
-// only), for the reason budget-meter.test.ts gives: connecting subscribes to
-// `agenticActivityBus` and leaves the runner's event loop open.
-const Suite = createLogicSuite('settings-modal usage meters structure');
-const template = settingsUsageMetersTemplate('test-progress', 'test-button', 'test-icon');
-let storeSeq = 0;
-/** A fresh (unconnected) element wired to its own real session store. */
-function element() {
-    const el = document.createElement('foundation-ai-assistant');
-    storeSeq += 1;
-    el._sessionRef = getSessionStore(`usage-meters-test-${storeSeq}`, false);
-    return el;
-}
-/** Renders the meters for `el` into a detached host and returns it. */
-function render(el) {
-    const host = document.createElement('div');
-    template.render(el, host);
-    return host;
-}
-Suite.after(() => {
-    clearAllSessionStores();
-});
-Suite('both meters render inside one shared column', () => {
-    const el = element();
-    el.contextTokens = 1000;
-    el.contextLimit = 4000;
-    el.setVendorBudget('anthropic', { budgetUsd: 50, spentUsd: 45 });
-    const host = render(el);
-    const wrapper = host.querySelector('.settings-usage-meters');
-    assert.ok(wrapper, 'the shared column is rendered');
-    assert.ok(wrapper.querySelector('.settings-context-usage'), 'the context indicator is inside it');
-    assert.ok(wrapper.querySelector('.settings-budget-usage'), 'so is the budget meter');
-    // The rhythm the wrapper exists for: every meter row is a child of a 2-unit
-    // column, none of them of the section body's 4-unit one.
-    assert.is(host.querySelectorAll('.settings-usage-meters').length, 1, 'one column, not one per meter');
-});
-Suite('neither meter visible → no wrapper at all, not an empty one', () => {
-    // The stray-gap case. Nothing fed, no context figures: the section body must
-    // see no flex child from the meters.
-    const el = element();
-    const host = render(el);
-    assert.is(el.settingsContextUsageVisible, false, 'precondition: no context data');
-    assert.is(el.settingsBudgetUsageVisible, false, 'precondition: no budget data');
-    assert.is(host.querySelector('.settings-usage-meters'), null, 'no wrapper element');
-    assert.is(host.querySelectorAll('*').length, 0, 'and no element of any kind — comment markers only');
-});
-Suite('one meter alone still gets the shared column, with only its own child', () => {
-    // Both single-meter cases: the wrapper appears for either meter on its own,
-    // and the hidden sibling contributes NO element inside it (both gate with
-    // `when`, which emplaces comment markers, not empty divs — an empty div would
-    // be a second stray gap, inside the column this time).
-    const contextOnly = element();
-    contextOnly.contextTokens = 1000;
-    contextOnly.contextLimit = 4000;
-    const contextHost = render(contextOnly);
-    const contextWrapper = contextHost.querySelector('.settings-usage-meters');
-    assert.ok(contextWrapper, 'context alone still gets the column');
-    assert.is(contextWrapper.children.length, 1, 'the hidden budget meter adds no flex child');
-    assert.ok(contextWrapper.querySelector('.settings-context-usage'));
-    const budgetOnly = element();
-    budgetOnly.setVendorBudget('gemini', { budgetUsd: 50, spentUsd: 15 });
-    const budgetHost = render(budgetOnly);
-    const budgetWrapper = budgetHost.querySelector('.settings-usage-meters');
-    assert.ok(budgetWrapper, 'budget alone still gets the column');
-    assert.is(budgetWrapper.children.length, 1, 'the hidden context indicator adds no flex child');
-    assert.ok(budgetWrapper.querySelector('.settings-budget-usage'));
-});
-Suite.run();

package/dist/esm/config/define-stateful-agent.test.js

@@ -1,53 +0,0 @@
-import { __awaiter } from "tslib";
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { defineStatefulAgent } from './define-stateful-agent';
-// A minimal lifecycle context — `onActivate`/`onDeactivate` only read what the
-// helper passes through, so the agent name, session key, and a live signal are
-// enough to drive init/dispose in a Node-runnable test.
-const lifecycleCtx = () => ({
-    agentName: 'wizard',
-    sessionKey: 'test-session',
-    signal: new AbortController().signal,
-});
-const onUnresolvedTool = createLogicSuite('defineStatefulAgent onUnresolvedTool');
-onUnresolvedTool('threads the live state into the hook after init', () => __awaiter(void 0, void 0, void 0, function* () {
-    const config = defineStatefulAgent({
-        name: 'wizard',
-        description: 'guided wizard',
-        init: () => ({ step: 'intake' }),
-        onUnresolvedTool: ({ state, toolName, kind, availableTools }) => `step=${state.step} tool=${toolName} kind=${kind} avail=${availableTools.join(',')}`,
-    });
-    yield config.onActivate(lifecycleCtx());
-    const result = yield config.onUnresolvedTool({
-        toolName: 'generate_view',
-        kind: 'stale',
-        availableTools: ['ask_user', 'validate'],
-    });
-    assert.is(result, 'step=intake tool=generate_view kind=stale avail=ask_user,validate');
-}));
-onUnresolvedTool('returns undefined before init rather than throwing', () => __awaiter(void 0, void 0, void 0, function* () {
-    const config = defineStatefulAgent({
-        name: 'wizard',
-        description: 'guided wizard',
-        init: () => ({ step: 'intake' }),
-        // Would throw if it were ever reached without state — proves the wrapper
-        // short-circuits before delegating.
-        onUnresolvedTool: ({ state }) => `step=${state.step}`,
-    });
-    // No `onActivate` call — state has not been built yet.
-    const result = yield config.onUnresolvedTool({
-        toolName: 'generate_view',
-        kind: 'unknown',
-        availableTools: [],
-    });
-    assert.is(result, undefined, 'a pre-init call must degrade to the framework default');
-}));
-onUnresolvedTool('omits the hook from the config when not supplied', () => {
-    const config = defineStatefulAgent({
-        name: 'wizard',
-        description: 'guided wizard',
-        init: () => ({ step: 'intake' }),
-    });
-    assert.is(config.onUnresolvedTool, undefined);
-});
-onUnresolvedTool.run();

package/dist/esm/config/validate-providers.test.js

@@ -1,100 +0,0 @@
-import { __awaiter } from "tslib";
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { resolveChatProvider, validateStaticAgentProviders } from './validate-providers';
-const chatProvider = () => ({
-    chat: () => __awaiter(void 0, void 0, void 0, function* () { return ({ role: 'assistant', content: '' }); }),
-});
-const promptOnlyProvider = () => ({
-    prompt: () => __awaiter(void 0, void 0, void 0, function* () { return ''; }),
-});
-/**
- * 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) => {
-    const map = new Map(Object.entries(providers));
-    return {
-        get: (name) => map.get(name),
-        default: () => map.values().next().value,
-        defaultName: () => map.keys().next().value,
-        names: () => [...map.keys()],
-        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
-        listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
-    };
-};
-const specialist = (overrides) => (Object.assign({ name: overrides.name, description: 'test specialist' }, overrides));
-// ---------------------------------------------------------------------------
-// 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();