Function createEngine

packages/core/src/engine.ts:57–148

(
  config: ResolvedConfig,
  overrides: EngineOverrides = {},
)

}

export function createEngine(
  config: ResolvedConfig,
  overrides: EngineOverrides = {},
): Engine {
  const llmOpts = {
    provider: config.llmProvider,
    baseUrl: config.backendUrl ?? undefined,
  };
  const quick =
    overrides.quick ??
    createLlmClient({ ...llmOpts, model: config.quickThinkLlm });
  const deep =
    overrides.deep ??
    createLlmClient({ ...llmOpts, model: config.deepThinkLlm });
  const route = createRouter(
    config,
    buildVendorRegistry(overrides.fetchImpl),
  );
  const deps: AgentDeps = { quick, deep, route, config };

  const compile = (selected?: AnalystKey[], outputLanguage?: string) => {
    const runDeps =
      outputLanguage && outputLanguage !== config.outputLanguage
        ? { ...deps, config: { ...deps.config, outputLanguage } }
        : deps;
    return buildGraph(runDeps, { selectedAnalysts: selected ?? DEFAULT_ANALYSTS });
  };

  const makeState = (input: AnalyzeInput): AgentState =>
    createInitialState({
      ticker: input.ticker,
      tradeDate: input.tradeDate,
      assetType: input.assetType ?? detectAssetType(input.ticker),
      instrumentContext: input.instrumentContext,
      pastContext: input.pastContext,
    });

  return {
    async propagate(input) {
      const graph = compile(input.selectedAnalysts, input.outputLanguage);
      const finalState = (await graph.invoke(makeState(input), {
        recursionLimit: config.maxRecurLimit,
      })) as AgentState;
      const rating = processSignal(finalState.finalTradeDecision);
      return { finalState, rating };
    },

    async reflect(prompt: string): Promise<string> {
      const res = await deep.invoke({ messages: [{ role: "user", content: prompt }] });
      return res.content;
    },

    async *streamEvents(input, signal): AsyncIterable<RunEvent> {
      const graph = compile(input.selectedAnalysts, input.outputLanguage);
      const accumulated = makeState(input);
      try {
        const stream = await graph.stream(accumulated, {
          recursionLimit: config.maxRecurLimit,