Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
import { createRoot, createSignal } from 'solid-js';
import { describe, expect, it, vi } from 'vitest';
import type { RosterAgent } from '../core/roster';
import { composerModelTarget, createComposerModels } from './composer-models';
const discovery = vi.hoisted(() => ({
target: undefined as (() => unknown) | undefined,
enabled: undefined as (() => boolean) | undefined,
query: {} as object,
}));
vi.mock('@queries/agents/models', () => ({
useAgentModelsQuery: (target: () => unknown, enabled: () => boolean) => {
discovery.target = target;
discovery.enabled = enabled;
return discovery.query;
},
}));
describe('composer model discovery', () => {
it('uses runtime identities rather than bot ids to discover models', () => {
expect(composerModelTarget({ harness: 'macro-inmem' })).toEqual({
harness: 'in-memory',
});
expect(composerModelTarget({ harness: 'cursor' })).toEqual({
harness: 'cursor',
});
expect(
composerModelTarget({ harness: 'macrod', harnessId: 'paired-runtime' })
).toEqual({ harness: 'macrod', harnessId: 'paired-runtime' });
expect(composerModelTarget({ harness: 'macrod' })).toBeUndefined();
expect(composerModelTarget({ harness: 'sandbox' })).toBeUndefined();
expect(composerModelTarget({ harness: 'macro-inmem' })).toEqual({
harness: 'in-memory',
});
});
it('switches discovery targets with the selected agent and skips disconnected runtimes', () => {
createRoot((dispose) => {
const [agent, setAgent] = createSignal<RosterAgent>({
id: 'bot-one',
name: 'One',
handle: 'one',
kind: 'coder',
share: 'private',
harness: 'cursor',
runtime: { label: 'Cursor', connected: true },
});
createComposerModels(agent);
expect(discovery.enabled?.()).toBe(true);
expect(discovery.target?.()).toEqual({ harness: 'cursor' });
setAgent({ ...agent(), harness: 'in-memory' });
expect(discovery.target?.()).toEqual({ harness: 'in-memory' });
setAgent({ ...agent(), harness: 'macrod', harnessId: 'paired-runtime' });
expect(discovery.target?.()).toEqual({
harness: 'macrod',
harnessId: 'paired-runtime',
});
setAgent({ ...agent(), runtime: { label: 'Offline', connected: false } });
expect(discovery.enabled?.()).toBe(false);
expect(discovery.target?.()).toEqual({
harness: 'in-memory',
harnessId: 'composer-idle',
});
dispose();
});
});
it('does not read pending resource data and exposes discovered choices when ready', () => {
createRoot((dispose) => {
const [ready, setReady] = createSignal(false);
const models = [{ id: 'runtime-model', name: 'Runtime model' }];
discovery.query = {
get isSuccess() {
return ready();
},
get isPending() {
return !ready();
},
get isError() {
return false;
},
get data() {
if (!ready()) throw new Error('Pending resource must not be read');
return {
models,
currentModel: 'runtime-model',
status: 'available',
};
},
};
const source = createComposerModels(() => ({
id: 'bot',
name: 'Agent',
handle: 'agent',
kind: 'coder',
share: 'private',
harness: 'cursor',
runtime: { label: 'Cursor', connected: true },
}));
expect(source.models()).toEqual([]);
expect(source.message()).toBe('Loading models…');
setReady(true);
expect(source.models()).toEqual(models);
expect(source.currentModel()).toBe('runtime-model');
dispose();
});
});
});