File size: 5,698 Bytes
bc575bc | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 | import { type Context, defineFacet, type Facet, type MutableReplicatedState } from "@earendil-works/chord";
import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
import type { AgentLane, ThinkingLevel } from "@earendil-works/pi-agent-core";
import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
import type { ModelRuntime } from "../../core/model-runtime.ts";
import type { SettingsManager } from "../../core/settings-manager.ts";
import { Models, type Models as ModelsService, type ModelsState } from "./models.ts";
export interface ModelsServiceRuntime {
readonly service: ModelsService;
activate(context: Context): Promise<void>;
}
export function createModelsService(
lane: AgentLane,
modelRuntime: ModelRuntime | undefined,
settingsManager: SettingsManager | undefined,
createState: (initial: ModelsState) => MutableReplicatedState<ModelsState>,
): ModelsServiceRuntime {
let catalogRevision = 0;
const state = createState({
catalog: { revision: 0, availableModels: [] },
configuration: { model: null, thinkingLevel: "off" },
refresh: { status: "idle" },
});
const readConfiguration = async (context: Context): Promise<ModelsState["configuration"]> => {
const [selected, thinkingLevel] = await Promise.all([lane.getModel(context), lane.getThinkingLevel(context)]);
return {
model: selected === undefined ? null : { provider: selected.provider, modelId: selected.id },
thinkingLevel,
};
};
const readThinkingLevels = async (context: Context): Promise<ThinkingLevel[]> => {
const selected = await lane.getModel(context);
return selected === undefined ? ["off"] : getSupportedThinkingLevels(selected);
};
const readCatalog = async (context: Context): Promise<ModelsState["catalog"]> => {
const selected = await lane.getModel(context);
const available = modelRuntime?.getAvailableSnapshot() ?? [];
const catalog =
selected === undefined || includesModel(available, selected) ? available : [...available, selected];
catalogRevision += 1;
return {
revision: catalogRevision,
availableModels: catalog.map((model) => ({
provider: model.provider,
modelId: model.id,
name: model.name,
reasoning: model.reasoning,
})),
};
};
const service: ModelsService = {
state,
async cycleThinking(context) {
const levels = await readThinkingLevels(context);
const current = await lane.getThinkingLevel(context);
const index = levels.indexOf(current);
const next = levels[(index + 1) % levels.length] ?? "off";
await lane.setThinkingLevel(next, context);
state.state.configuration = await readConfiguration(context);
state.publish(context);
},
async getThinkingLevels(context) {
return [...(await readThinkingLevels(context))];
},
async refresh(context) {
state.state.refresh = { status: "refreshing" };
state.publish(context);
const refresh = modelRuntime?.refresh({ signal: context.abortSignal });
if (refresh === undefined) {
const [catalog, configuration] = await Promise.all([readCatalog(context), readConfiguration(context)]);
state.state.catalog = catalog;
state.state.configuration = configuration;
state.state.refresh = { status: "done" };
state.publish(context);
return;
}
const result = await refresh;
const errors = Object.fromEntries([...result.errors].map(([id, error]) => [id, error.message]));
const [catalog, configuration] = await Promise.all([readCatalog(context), readConfiguration(context)]);
state.state.catalog = catalog;
state.state.configuration = configuration;
state.state.refresh = Object.keys(errors).length === 0 ? { status: "done" } : { status: "warning", errors };
state.publish(context);
},
async select(model, context) {
const selected = modelRuntime?.getModel(model.provider, model.modelId);
if (selected === undefined) throw new Error(`Unknown model: ${model.provider}/${model.modelId}`);
await lane.setModel({ provider: selected.provider, modelId: selected.id }, context);
settingsManager?.setDefaultModelAndProvider(selected.provider, selected.id);
await settingsManager?.flush();
state.state.configuration = await readConfiguration(context);
state.publish(context);
},
async selectThinking(level, context) {
const levels = await readThinkingLevels(context);
if (!levels.includes(level)) {
throw new Error(`Thinking level ${level} is unavailable; choose one of: ${levels.join(", ")}`);
}
await lane.setThinkingLevel(level, context);
state.state.configuration = await readConfiguration(context);
state.publish(context);
},
};
return {
service,
async activate(context) {
const [catalog, configuration] = await Promise.all([readCatalog(context), readConfiguration(context)]);
state.state.catalog = catalog;
state.state.configuration = configuration;
state.state.refresh = { status: "idle" };
state.publish(context);
},
};
}
export function createModelsServiceFacet(options: {
readonly lane: AgentLane;
readonly modelRuntime: ModelRuntime | undefined;
readonly settingsManager?: SettingsManager;
}): Facet {
return defineFacet({
id: "@pi/models",
setup(env) {
const runtime = createModelsService(
options.lane,
options.modelRuntime,
options.settingsManager,
env.replicatedState,
);
env.provide(Models, runtime.service);
env.onActivate(() => runtime.activate(BACKGROUND_CONTEXT));
},
});
}
function includesModel(
models: readonly { readonly provider: string; readonly id: string }[],
selected: { readonly provider: string; readonly id: string },
): boolean {
return models.some((model) => model.provider === selected.provider && model.id === selected.id);
}
|