@memberjunction/ai-agents 6.2.0-edge.1 → 6.2.0-edge.2

package/dist/decision-discovery.d.ts

@@ -0,0 +1,401 @@
+/**
+ * @fileoverview Decision discovery (typed-decision plan, Task 3.1): the pure half.
+ *
+ * When the user names no agent, a conversation manager such as Sage takes two turns to delegate: it
+ * calls Find Candidate Agents, then reads the rows and picks one. With the Loop prompt param
+ * `decisionDiscovery` on, `BaseAgent` instead asks one decision before the first prompt of a
+ * conversation's opening turn: a Choice over the agents the user may run, and a Likelihood that a
+ * specialist agent should handle the request. When both answers are confident, a `<suggested_agent>`
+ * system message reaches the first prompt, so the agent can delegate in its first turn. These helpers
+ * build the options and questions, judge the answers and format the message. The call, the
+ * `Agent discovery` step and the injection live on `BaseAgent`.
+ *
+ * It fails safe: after an error, a timeout, an unusable answer or an unsure one, nothing is injected
+ * and the agent behaves as it did before. A follow-up turn is never asked about (see
+ * {@link IsOpeningTurn}), so discovery never pulls the agent away from one it has already engaged.
+ *
+ * Known limitation, kept on purpose: the Likelihood does not name the options, so "none of these
+ * agents fits" cannot be expressed (see {@link DECISION_DISCOVERY_APPLIES_INSTRUCTIONS}).
+ *
+ * @module @memberjunction/ai-agents
+ */
+import { type ChatMessage, type DecisionAnswer, type DecisionQuestion, type PlattCalibration } from '@memberjunction/ai';
+import type { AIDecisionRunResult } from '@memberjunction/ai-prompts';
+import { type DecisionAnsweringModel, type DecisionModelCalibration } from '@memberjunction/ai-core-plus';
+import type { AIEngine } from '@memberjunction/aiengine';
+import type { EntitySearchResult, IRunViewProvider, UserInfo } from '@memberjunction/core';
+import type { MJAIAgentEntity } from '@memberjunction/core-entities';
+/**
+ * The most options the Choice ever offers. It always applies: the limit is this, or the decision
+ * model's declared `MaxChoiceOptions` when that is smaller. A larger catalog is first narrowed to
+ * the limit by the semantic search Find Candidate Agents uses.
+ */
+export declare const DECISION_DISCOVERY_MAX_OPTIONS = 25;
+/**
+ * The least **calibrated** confidence at which the suggestion is shown (see
+ * {@link DECISION_DISCOVERY_CALIBRATION}). Both the Choice's confidence and the Likelihood that any
+ * agent applies must reach it.
+ *
+ * Set from the agent-discovery Decision Eval (plan Task 3.1, 2026-09-29): 258 labelled requests, 198
+ * for one of 33 agents and 60 for none, three repeats per model, calibrated out of fold, and scored
+ * as production would, so an answer after {@link DECISION_DISCOVERY_TIMEOUT_MS} injects nothing. At a
+ * calibrated 0.85, Jev's suggestion covered 21.7% of the requests meant for an agent, and named the
+ * right agent for 95.3% of those it covered. It was shown for 5.0% of the requests meant for no agent,
+ * all of them multi-agent workflows. Every Jev discovery but the run's first, which loaded the
+ * embedding model, finished within the timeout. LLM Decision finished within it for at least 67.7% of
+ * requests, and covered at least 16.0% at 92.6% precision, shown for 5.0%. A wrong suggestion costs
+ * more than a missed one, which is only the two-turn flow the agent used before, so the threshold
+ * favours precision. On raw probabilities the old 0.7 almost never fired: Jev's raw any-applies
+ * Likelihood never passed 0.8, so it covered 6.9%.
+ */
+export declare const DECISION_DISCOVERY_MIN_CONFIDENCE = 0.85;
+/** A decision model's Platt calibration of the two discovery answers. */
+export interface DecisionDiscoveryCalibration {
+    /** The Choice's confidence, as the probability that the chosen agent is the right one. */
+    Confidence: PlattCalibration;
+    /** The Likelihood that a specialist agent should handle the request. */
+    AnyApplies: PlattCalibration;
+}
+/**
+ * Platt calibration of the discovery answers, each tied to the exact model it was fitted on (see
+ * `FindDecisionCalibration` in `@memberjunction/ai-core-plus`): the MJ decision model that answered
+ * (`ModelName`, from `modelInfo.modelName`) and the model its driver reports behind it
+ * (`ResolvedModel`, from `DecisionResult.ResolvedModel`). A model's raw answers are not calibrated:
+ * Jev's raw any-applies Likelihood sits between 0.1 and 0.8 whatever the request. Any other model,
+ * including Jev at another version or `LLM Decision` answered by another chat model, is treated as
+ * unsure, so its answer suggests nothing.
+ *
+ * Fitted on the agent-discovery Decision Eval (2026-09-29; 258 requests, 3 repeats per model, 774
+ * answers each): the Choice's confidence against whether it named the labelled agent (594 answers
+ * to requests meant for an agent), and the Likelihood against whether the request was meant for an
+ * agent (all 774). Every fit converged (5 to 7 Newton iterations; a 60-digit refit agrees to 4
+ * places).
+ * - **Jev** at its pinned `APIName`, `typesafe/jev-1.13-20260917`, which it reports back as the
+ *   resolved model.
+ * - **LLM Decision** when its chat model is GPT-OSS-120B, which answered all 774 of its runs.
+ *
+ * Refit, and add the new pair, whenever a model, its version, the questions or the catalog's shape
+ * changes.
+ */
+export declare const DECISION_DISCOVERY_CALIBRATION: readonly DecisionModelCalibration<DecisionDiscoveryCalibration>[];
+/**
+ * The answers with the Choice's confidence and the Likelihood calibrated for the exact model that
+ * gave them ({@link DECISION_DISCOVERY_CALIBRATION}), or null when that model has no discovery
+ * calibration. Other answers, and the Choice's distribution, are returned as they are.
+ *
+ * @param answers - The raw answers, by question key.
+ * @param answeredBy - The decision model that answered, and the model behind it.
+ */
+export declare function CalibrateDiscoveryAnswers(answers: Record<string, DecisionAnswer>, answeredBy: DecisionAnsweringModel): Record<string, DecisionAnswer> | null;
+/**
+ * The longest decision discovery may delay the run's first prompt. Past it the run moves on, the
+ * decision call is aborted, and nothing is injected.
+ */
+export declare const DECISION_DISCOVERY_TIMEOUT_MS = 1500;
+/**
+ * The fewest options discovery asks about. Below it nothing is asked and nothing is suggested.
+ *
+ * Two options are not enough, although the Choice is well-formed: its probabilities sum to 1, so its
+ * top answer is at least 0.5 however poorly both agents fit, and the any-applies Likelihood cannot
+ * vouch for them (see {@link DECISION_DISCOVERY_APPLIES_INSTRUCTIONS}). A confidence threshold then
+ * sits only a little above chance. The discovery eval (#4892) offered every request dozens of
+ * options, so this bound leaves the measured case alone. With fewer options the agent falls back to
+ * Find Candidate Agents, as it would without discovery.
+ */
+export declare const DECISION_DISCOVERY_MIN_OPTIONS = 3;
+/** The Choice's question key: which agent should handle the request. */
+export declare const DECISION_DISCOVERY_AGENT_QUESTION = "agent";
+/** The Likelihood's question key: whether any of the agents should. */
+export declare const DECISION_DISCOVERY_APPLIES_QUESTION = "anyApplies";
+/**
+ * The Likelihood's instructions. They stand on the request alone, because a driver may answer each
+ * question separately and never see the Choice's options.
+ *
+ * **Known limitation.** Because they name no agent, the Likelihood measures "is this specialist
+ * work?", not "does one of *these* agents fit?". A per-question driver, such as the Default
+ * Decision prompt's top-priority binding, answers each question on its own, so it never sees the
+ * options while answering this one. The Choice cannot say "none" either: its probabilities sum to
+ * 1 over the options it is given. So when the options leave out the agent the request needs (a host
+ * allow-list of a Billing and a Marketing agent, and a request for a legal review), both answers can
+ * still clear the threshold and suggest an agent that does not fit. The suggestion stays advisory,
+ * and the agent's prompt keeps the "unless the request clearly needs something else" escape.
+ *
+ * **Why the wording stays.** The discovery eval (#4892) measured, and the calibration (#4893)
+ * calibrated, exactly this question: its per-model Platt parameters and threshold hold only for this
+ * wording. Rewording it invalidates both, so the fix (quoting the options, or one Likelihood per
+ * option) waits for a re-measurement, tracked in #4938. Meanwhile {@link DECISION_DISCOVERY_MIN_OPTIONS} closes the
+ * worst case, two options, and leaves the measured case unchanged.
+ */
+export declare const DECISION_DISCOVERY_APPLIES_INSTRUCTIONS = "This request asks for work that a specialist agent should do, rather than something the conversation manager should answer directly or plan as a multi-agent workflow.";
+/** The entity the semantic search ranks when the catalog is over the limit, as Find Candidate Agents does. */
+export declare const DECISION_DISCOVERY_SEARCH_ENTITY = "MJ: AI Agents";
+/**
+ * The `ExecuteAgentParams.data` key holding the host's catalog of agents the conversation manager
+ * may route to (`ConversationAgentRunner` sets it, narrowed to the host's `AllowedAgentIDs`).
+ */
+export declare const DECISION_DISCOVERY_HOST_AGENTS_KEY = "ALL_AVAILABLE_AGENTS";
+/** The most agent IDs the step records in a list, such as the agents left out for having no description. */
+export declare const DECISION_DISCOVERY_MAX_RECORDED_IDS = 50;
+/** One agent the Choice can pick. */
+export interface DecisionDiscoveryOption {
+    /** The agent's ID: the option's value. */
+    ID: string;
+    /** The agent's name: used in the suggestion and the step, never shown to the decision model. */
+    Name: string;
+    /** The agent's description: what the decision model reads. */
+    Description: string;
+}
+/** A valid answer to the two questions, in terms of the options. */
+export interface DecisionDiscoveryAnswer {
+    /** The agent the Choice picked. */
+    Agent: DecisionDiscoveryOption;
+    /** The Choice's confidence. */
+    Confidence: number;
+    /** The Likelihood that a specialist agent should handle the request ({@link DECISION_DISCOVERY_APPLIES_INSTRUCTIONS}). */
+    AnyApplies: number;
+    /** The Choice's distribution, by agent name. */
+    Probabilities: Record<string, number>;
+}
+/** What the answers mean for the prompt. */
+export interface DecisionDiscoveryVerdict {
+    /** The answer, when both questions were answered validly. */
+    Answer?: DecisionDiscoveryAnswer;
+    /** Whether the suggestion is shown: both answers at or above the threshold. */
+    Confident: boolean;
+    /** Why it is not shown. */
+    Reason?: string;
+}
+/** What one run's decision discovery did. `BaseAgent` records it as the `Agent discovery` step. */
+export interface DecisionDiscoveryOutcome {
+    /** Whether the `<suggested_agent>` message goes into the first prompt. */
+    Injected: boolean;
+    /** The message, when it is injected. */
+    Message?: string;
+    /**
+     * False when discovery failed: an error, a timeout, a cancelled run, or an answer it could not
+     * use. True when the decision gave a valid answer, confident or not.
+     */
+    Succeeded: boolean;
+    /** Why nothing is injected. */
+    Reason?: string;
+    /** How many agents the user may delegate to: the catalog before any narrowing. */
+    CatalogSize?: number;
+    /** How many IDs the host's allow-list held, when the run carried one. The catalog was cut to it. */
+    HostAllowListSize?: number;
+    /** The IDs of the catalog agents left out of the options for having no description. */
+    WithoutDescription?: string[];
+    /** How many options the Choice offered. */
+    OptionCount?: number;
+    /** The most options the Choice may offer: see {@link DecisionOptionLimit}. */
+    OptionLimit?: number;
+    /** The decision model's option cap, when one is declared. */
+    DeclaredOptionCap?: number;
+    /** The number of options before the semantic search narrowed them. Set only when it did. */
+    NarrowedFrom?: number;
+    /** The answer, when there was a valid one. */
+    Answer?: DecisionDiscoveryAnswer;
+    /** The decision call's result, for its usage. */
+    Result?: AIDecisionRunResult;
+    /**
+     * The model behind the answer (`DescribeAnsweringModel`), when it has no discovery calibration,
+     * so its answer was treated as unsure: discovery never suggests anything for it.
+     */
+    UncalibratedModel?: string;
+}
+/**
+ * The Choice's options for one run, and how they were reached from the catalog. Its members other
+ * than `Options` and `Error` carry over into the {@link DecisionDiscoveryOutcome}.
+ */
+export interface DecisionDiscoveryOptionSet {
+    /** The options to offer. */
+    Options: DecisionDiscoveryOption[];
+    /** Why the options could not be built, when they could not. */
+    Error?: string;
+    /** See {@link DecisionDiscoveryOutcome.CatalogSize}. */
+    CatalogSize: number;
+    /** See {@link DecisionDiscoveryOutcome.HostAllowListSize}. */
+    HostAllowListSize?: number;
+    /** See {@link DecisionDiscoveryOutcome.WithoutDescription}. */
+    WithoutDescription: string[];
+    /** See {@link DecisionDiscoveryOutcome.OptionLimit}. */
+    OptionLimit: number;
+    /** See {@link DecisionDiscoveryOutcome.DeclaredOptionCap}. */
+    DeclaredOptionCap?: number;
+    /** See {@link DecisionDiscoveryOutcome.NarrowedFrom}. */
+    NarrowedFrom?: number;
+}
+/** A discovery that failed: nothing is injected. */
+export declare function FailedDecisionDiscovery(reason: string): DecisionDiscoveryOutcome;
+/**
+ * Whether the `decisionDiscovery` setting is on in merged agent-type prompt params. Only `true` turns it
+ * on. Discovery runs only when the master switch, `decisionsEnabled`, is on as well: `BaseAgent` checks both.
+ */
+export declare function IsDecisionDiscoveryOn(promptParams: Record<string, unknown> | undefined): boolean;
+/**
+ * Whether a run answers a conversation's opening request, the only turn discovery asks about: its
+ * messages hold exactly one user message. A follow-up turn carries the earlier requests in its
+ * history (or the summary of them, which also arrives as a user message), and may be continuing work
+ * with an agent already engaged, which a suggestion must not pull the agent away from. Assistant and
+ * system messages do not count, so a greeting before the first request still leaves it the opening
+ * turn. Read it from the messages the run started with, before the framework adds any.
+ *
+ * @param messages - The run's conversation messages, as the run received them.
+ */
+export declare function IsOpeningTurn(messages: ReadonlyArray<ChatMessage> | undefined): boolean;
+/**
+ * Whether the request @mentions an agent other than the one running, in which case the user has
+ * already chosen and discovery does not run. It recognises both forms a mention takes by the time a
+ * run starts: the composer's `@{"_mode":"mention","type":"agent",...}` token, and the "@Agent Name"
+ * text `BaseAgent` converts that token to (or that the user typed). Names match whole, in any case.
+ * A mention of the running agent itself does not count: it names no one to delegate to.
+ *
+ * @param request - The run's opening request.
+ * @param agents - Every agent a mention could name.
+ * @param selfID - The running agent's ID.
+ */
+export declare function MentionsAgent(request: string, agents: ReadonlyArray<{
+    ID: string;
+    Name: string | null;
+}>, selfID: string): boolean;
+/**
+ * The Choice's options: one per agent with a description, in catalog order. An agent with a blank
+ * description is left out, because the decision model reads only descriptions and the decision
+ * primitive rejects an option without one.
+ */
+export declare function DecisionDiscoveryOptions(agents: ReadonlyArray<{
+    ID: string;
+    Name: string;
+    Description: string | null;
+}>): DecisionDiscoveryOption[];
+/** The IDs of the agents {@link DecisionDiscoveryOptions} leaves out for having a blank description, in catalog order. */
+export declare function AgentsWithoutDescription(agents: ReadonlyArray<{
+    ID: string;
+    Description: string | null;
+}>): string[];
+/**
+ * The agent IDs in the host's allow-list, when the run carries one: the `ID` of each entry of
+ * `data[`{@link DECISION_DISCOVERY_HOST_AGENTS_KEY}`]` when that is an array. `undefined` when it is
+ * absent or not an array. An empty array is an allow-list that allows no one.
+ */
+export declare function HostAllowedAgentIDs(data: Record<string, unknown> | undefined): string[] | undefined;
+/**
+ * The agents the host allows, in their original order, compared UUID-safely. Without an allow-list
+ * every agent is kept, and `agents` itself is returned.
+ */
+export declare function KeepHostAllowedAgents<T extends {
+    ID: string;
+}>(agents: T[], allowedIDs: ReadonlyArray<string> | undefined): T[];
+/**
+ * The smallest option cap any of the decision prompt's models declares, or `undefined` when none
+ * does. The runner may answer with any of them after failover, so the smallest is the one they all
+ * accept. Anything but a positive number declares no cap.
+ */
+export declare function SmallestOptionCap(caps: ReadonlyArray<number | null | undefined>): number | undefined;
+/**
+ * The most options the Choice may offer: {@link DECISION_DISCOVERY_MAX_OPTIONS}, or the model's
+ * declared cap when that is smaller. It always applies, declared cap or not. More options than this
+ * are narrowed first.
+ */
+export declare function DecisionOptionLimit(declaredCap: number | undefined): number;
+/**
+ * Keeps the options the semantic search returned, in its rank order, up to `limit`. An option the
+ * search did not return is dropped, and a result that is not an option (an agent the user may not
+ * run, say) is skipped.
+ */
+export declare function RankOptionsBySearch(options: ReadonlyArray<DecisionDiscoveryOption>, rankedIDs: ReadonlyArray<string>, limit: number): DecisionDiscoveryOption[];
+/**
+ * The two questions, asked about the opening request in one call: a Choice over the options, whose
+ * values are agent IDs and whose descriptions are the agents' descriptions, and a Likelihood,
+ * {@link DECISION_DISCOVERY_APPLIES_INSTRUCTIONS}, that stands on the request alone.
+ *
+ * Neither can say that none of the options fits: the Likelihood never sees them, and the Choice's
+ * probabilities sum to 1 over them. The wording is what the discovery eval measured and calibrated,
+ * so it changes only with a re-measurement (see {@link DECISION_DISCOVERY_APPLIES_INSTRUCTIONS}).
+ *
+ * @param options - The agents to choose from.
+ */
+export declare function BuildDecisionDiscoveryQuestions(options: ReadonlyArray<DecisionDiscoveryOption>): Record<string, DecisionQuestion>;
+/**
+ * Judges the answers. Confident means the Choice's confidence and the Likelihood both reach
+ * `minConfidence`. An answer that is missing, of the wrong kind, not a finite number, or names no
+ * option gives no answer at all.
+ */
+export declare function JudgeDecisionDiscovery(answers: Record<string, DecisionAnswer>, options: ReadonlyArray<DecisionDiscoveryOption>, minConfidence?: number): DecisionDiscoveryVerdict;
+/**
+ * What a finished decision call means for the prompt: the suggestion when both **calibrated**
+ * answers are confident, otherwise nothing, with the reason. A failed call, or an answer that cannot
+ * be used, is a failed discovery. An answer from a model with no discovery calibration is unsure.
+ */
+export declare function DecisionDiscoveryFromResult(result: AIDecisionRunResult, options: ReadonlyArray<DecisionDiscoveryOption>, minConfidence?: number): DecisionDiscoveryOutcome;
+/** The system message placed before the first prompt when the answer is confident. */
+export declare function SuggestedAgentMessage(agent: DecisionDiscoveryOption, confidence: number): string;
+/**
+ * Whether a provider can run `SearchEntity`. It is declared on `IRunViewProvider`, which every real
+ * provider implements alongside `IMetadataProvider`.
+ */
+export declare function CanSearchEntities<T extends object>(provider: T | undefined): provider is T & Pick<IRunViewProvider, 'SearchEntity'>;
+/** The fields of an agent that discovery reads. Every `MJAIAgentEntity` has them. */
+export type DecisionDiscoveryAgent = Pick<MJAIAgentEntity, 'ID' | 'Name' | 'Description' | 'Status' | 'InvocationMode' | 'ParentID'>;
+/**
+ * The semantic search that ranks agents for one request, best first: see
+ * {@link DecisionDiscoveryAgentSearch}. It returns at most `topK` results.
+ */
+export type DecisionDiscoverySearch = (topK: number) => Promise<EntitySearchResult[]>;
+/** What {@link BuildDecisionDiscoveryOptionSet} builds the Choice's options from. */
+export interface DecisionDiscoveryOptionSetParams {
+    /** The agents the user may run: {@link DecisionDiscoveryRunnableAgents} over the engine's catalog. */
+    Agents: ReadonlyArray<DecisionDiscoveryAgent>;
+    /** The agent running discovery, such as Sage. It is never an option. */
+    RunningAgentID: string;
+    /** The host's allow-list ({@link HostAllowedAgentIDs}), when the run carries one. */
+    HostAllowedIDs?: ReadonlyArray<string>;
+    /** The decision model's option cap ({@link DecisionPromptOptionCap}), when one is declared. */
+    DeclaredCap?: number;
+    /** Narrows a catalog over the limit. Undefined when the provider cannot run the search. */
+    Search?: DecisionDiscoverySearch;
+}
+/**
+ * The agents a user may run, as Find Candidate Agents filters them: through
+ * {@link AIAgentPermissionHelper.FilterRunnableAgents} (Active, with run permission), in catalog order.
+ *
+ * @param agents - The catalog: `AIEngine.Instance.Agents`.
+ * @param contextUser - The user whose run permission decides.
+ */
+export declare function DecisionDiscoveryRunnableAgents<T extends DecisionDiscoveryAgent>(agents: T[], contextUser: UserInfo): Promise<T[]>;
+/**
+ * The agents this run may suggest: of the agents the user may run, the ones that can be discovered
+ * directly (the set Find Candidate Agents offers, through the same {@link AIAgentPermissionHelper}
+ * filter), minus the running agent itself. In catalog order.
+ *
+ * @param agents - The agents the user may run ({@link DecisionDiscoveryRunnableAgents}).
+ * @param runningAgentID - The agent running discovery.
+ */
+export declare function DecisionDiscoveryCatalog<T extends Pick<DecisionDiscoveryAgent, 'ID' | 'InvocationMode' | 'ParentID'>>(agents: ReadonlyArray<T>, runningAgentID: string): T[];
+/**
+ * The decision model's option cap: the smallest `Decision.MaxChoiceOptions` in the effective model
+ * configuration of the models the decision prompt is bound to, the setting `AIDecisionRunner`
+ * checks before its call. `undefined` when none declares one, or the prompt is not found.
+ *
+ * @param engine - The loaded engine: `AIEngine.Instance`.
+ * @param promptName - The decision prompt's name, matched whole in any case.
+ */
+export declare function DecisionPromptOptionCap(engine: Pick<AIEngine, 'Prompts' | 'PromptModels' | 'ModelVendors' | 'GetEffectiveModelConfiguration'>, promptName: string): number | undefined;
+/**
+ * The search Find Candidate Agents runs, for one request: hybrid over
+ * {@link DECISION_DISCOVERY_SEARCH_ENTITY}. Its similarity floor is not applied: the caller judges fit.
+ *
+ * @param provider - A provider that can search ({@link CanSearchEntities}).
+ * @param request - The request to rank agents for.
+ * @param contextUser - The user the search runs as.
+ */
+export declare function DecisionDiscoveryAgentSearch(provider: Pick<IRunViewProvider, 'SearchEntity'>, request: string, contextUser: UserInfo): DecisionDiscoverySearch;
+/**
+ * The Choice's options, rebuilt on every call and never cached: the agents in the permitted
+ * catalog ({@link DecisionDiscoveryCatalog}) that the host allows and that have a description.
+ * There are never more than {@link DecisionOptionLimit}: when there are, the semantic search narrows
+ * them first; if it cannot, `Error` says why.
+ *
+ * @param params - The permitted agents, the running agent, the host's allow-list, the option cap and the search.
+ */
+export declare function BuildDecisionDiscoveryOptionSet(params: DecisionDiscoveryOptionSetParams): Promise<DecisionDiscoveryOptionSet>;
+//# sourceMappingURL=decision-discovery.d.ts.map

package/dist/decision-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision-discovery.d.ts","sourceRoot":"","sources":["../src/decision-discovery.ts"],"names":[],"mappings":"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"}