actoviq-agent-sdk 0.4.11 → 0.4.13

package/dist/src/types.d.ts

@@ -151,6 +151,13 @@ export interface CreateToolOptions<Input = any, Output = any> {
     examples?: Array<Record<string, unknown>>;
     isReadOnly?: (input?: Input) => boolean;
     isDestructive?: (input?: Input) => boolean;
+    /**
+     * Plan-mode-only read-only classification (S1b §9.5): evaluated only in
+     * plan mode when the tool is otherwise unclassified — lets the Agent tool
+     * allow delegations to read-only subagents without changing default-mode
+     * behavior.
+     */
+    isPlanReadOnly?: (input?: Input) => boolean;
     requiresUserInteraction?: () => boolean;
     isConcurrencySafe?: () => boolean;
     checkPermissions?: (context: {
@@ -192,6 +199,13 @@ export interface AgentToolDefinition<Input = any, Output = any> {
     examples?: Array<Record<string, unknown>>;
     isReadOnly?: (input?: Input) => boolean;
     isDestructive?: (input?: Input) => boolean;
+    /**
+     * Plan-mode-only read-only classification (S1b §9.5): evaluated only in
+     * plan mode when the tool is otherwise unclassified — lets the Agent tool
+     * allow delegations to read-only subagents without changing default-mode
+     * behavior.
+     */
+    isPlanReadOnly?: (input?: Input) => boolean;
     requiresUserInteraction?: () => boolean;
     isConcurrencySafe?: () => boolean;
     checkPermissions?: (context: {
@@ -273,6 +287,8 @@ export interface ResolvedToolAdapter {
     execute: (input: unknown, context: ToolExecutionContext, onProgress?: ToolCallProgress) => Promise<ResolvedToolExecutionResult>;
     isReadOnly?: (input?: unknown) => boolean;
     isDestructive?: (input?: unknown) => boolean;
+    /** Plan-mode-only read-only classification (S1b §9.5). */
+    isPlanReadOnly?: (input?: unknown) => boolean;
     requiresUserInteraction?: () => boolean;
     isConcurrencySafe?: () => boolean;
     interruptBehavior?: 'cancel' | 'block';
@@ -320,6 +336,7 @@ export interface ResolvedRuntimeConfig {
     userId?: string;
     metadata: Record<string, unknown>;
     compact: HadamardCompactConfig;
+    projectMemory: import('./config/projectSettings.js').ProjectMemorySettings;
     provider: 'anthropic' | 'openai';
     effort?: HadamardEffort;
     sandbox: import('./sandbox/types.js').SandboxPolicy;
@@ -404,8 +421,32 @@ export interface HadamardAgentDefinition {
     description: string;
     systemPrompt?: string;
     model?: string;
+    /** Referenced provider/bridge config name (unified store, S1a) — the definition runs on this config's own model client instead of inheriting the session's. */
+    bridgeConfig?: string;
+    /**
+     * Delegation runtime (09 Aug 2026): absent or 'hadamard' = in-process SDK;
+     * an external CLI runtime id ('claude' | 'pi' | 'codex' | …) routes Agent/Task
+     * delegations to that CLI via the bridge runner. Main-chat activation ignores
+     * this field (the main chat runtime comes from the active config).
+     */
+    runtime?: string;
+    /**
+     * Prompt composition (S1a): `extend` = built-in base prompt + body appended
+     * (profile semantics); `replace` = body is the complete system prompt
+     * (.md semantics). Definitions loaded from .md default to `replace`.
+     */
+    promptMode?: 'extend' | 'replace';
     effort?: HadamardRunEffort;
     permissionMode?: HadamardPermissionMode;
+    temperature?: number;
+    topP?: number;
+    maxTokens?: number;
+    /** Run timeout (ms) for runs under this definition. */
+    timeoutMs?: number;
+    /** `workspace` (default): project workspace only; `full`: unrestricted filesystem. */
+    workspaceAccess?: 'workspace' | 'full';
+    /** Whether the Agent/Task tool may delegate to this definition (default true). `false` = main-chat-only agent. */
+    subagent?: boolean;
     maxToolIterations?: number;
     maxTurns?: number;
     metadata?: Record<string, unknown>;
@@ -432,6 +473,10 @@ export interface HadamardAgentDefinitionSummary {
     name: string;
     description: string;
     model?: string;
+    /** Present when the definition pins a provider config (unified store). */
+    bridgeConfig?: string;
+    /** False = main-chat-only agent (not delegatable via the Agent/Task tool). */
+    subagent?: boolean;
     effort?: HadamardRunEffort;
     permissionMode?: HadamardPermissionMode;
     maxToolIterations?: number;
@@ -599,7 +644,7 @@ export interface HadamardRunSlashCommandOptions {
 export interface HadamardRunSlashCommandResult {
     name: HadamardCleanSlashCommandName;
     text: string;
-    data: HadamardCleanContextOverview | HadamardSessionCompactResult | HadamardMemoryState | HadamardDreamRunResult | HadamardCleanToolMetadata[] | HadamardSkillDefinitionSummary[] | HadamardAgentDefinitionSummary[];
+    data: HadamardCleanContextOverview | HadamardSessionCompactResult | HadamardMemoryState | HadamardDreamRunResult | HadamardDreamState | HadamardCleanToolMetadata[] | HadamardSkillDefinitionSummary[] | HadamardAgentDefinitionSummary[] | import('./memory/memoryCommandService.js').HadamardMemoryCommandResult;
 }
 export interface HadamardInvokedSkillRecord {
     name: string;
@@ -613,6 +658,27 @@ export interface HadamardInvokedSkillRecord {
     agent?: string;
     skillRoot?: string;
 }
+/** One-shot external-CLI delegation request (agent runtime routing, 09 Aug 2026). */
+export interface ExternalAgentRunRequest {
+    /** External runtime id (e.g. 'claude', 'codex'); never 'hadamard' here. */
+    runtime: string;
+    /** Definition name — used in error messages. */
+    agentName: string;
+    prompt: string;
+    systemPrompt?: string;
+    cwd: string;
+    signal?: AbortSignal;
+    model?: string;
+    /** Definition-pinned permission mode; the runner maps it to bridge semantics. */
+    permissionMode?: string;
+    homeDir?: string;
+}
+export interface ExternalAgentRunResult {
+    text: string;
+    sessionId?: string;
+    durationMs?: number;
+    numTurns?: number;
+}
 export interface CreateAgentSdkOptions {
     homeDir?: string;
     apiKey?: string;
@@ -645,6 +711,12 @@ export interface CreateAgentSdkOptions {
     agentDirectories?: string[];
     loadDefaultAgentDirectories?: boolean;
     disableDefaultAgents?: boolean;
+    /**
+     * Override the external-CLI delegation runner (definitions with
+     * `runtime` ≠ 'hadamard'). Defaults to the bridge runner in
+     * runtime/externalAgentRunner.ts; inject a stub in tests.
+     */
+    externalAgentRunner?: (request: ExternalAgentRunRequest) => Promise<ExternalAgentRunResult>;
     maxSubagentDepth?: number;
     maxSubagentFanout?: number;
     skills?: HadamardSkillDefinition[];
@@ -677,8 +749,13 @@ export interface CreateAgentSdkOptions {
 }
 export interface HadamardCompactConfig {
     enabled: boolean;
-    autoCompactThresholdTokens: number;
+    /** @deprecated Use autoCompactTokenLimit. Retained as a legacy explicit override. */
+    autoCompactThresholdTokens?: number;
+    /** Explicit limit, clamped to 90% of the raw context window. */
+    autoCompactTokenLimit?: number;
+    autoCompactTokenLimitScope?: 'total' | 'body_after_prefix';
     preserveRecentMessages: number;
+    preserveRecentUserTokens?: number;
     maxSummaryTokens: number;
     microcompactEnabled: boolean;
     microcompactKeepRecentToolResults: number;
@@ -704,7 +781,12 @@ export interface HadamardCompactConfig {
     loopAutoCompactEnabled?: boolean;
     /** Model context window in tokens used to derive the in-loop compact threshold. */
     contextWindowTokens?: number;
-    /** Explicit in-loop compact trigger in estimated tokens. Overrides the derived threshold. */
+    maxContextWindowTokens?: number;
+    effectiveContextWindowPercent?: number;
+    contextWindowSource?: 'run' | 'project' | 'global' | 'model_catalog' | 'fallback';
+    contextWindowWarning?: string;
+    deprecationWarnings?: string[];
+    /** @deprecated Use autoCompactTokenLimit. */
     loopAutoCompactThresholdTokens?: number;
     /**
      * Persistent user guidance injected into every compact summary prompt.
@@ -759,6 +841,12 @@ export interface AgentRunOptions {
     /** Override the model client for this run — used by the /model router for cross-provider routing. */
     modelApi?: CreateAgentSdkOptions['modelApi'];
     maxTokens?: number;
+    /** Per-run tool-iteration cap; overrides the SDK config cap for this run. */
+    maxToolIterations?: number;
+    /** Restrict the effective default/custom tool catalog to these names. */
+    allowedTools?: string[];
+    /** Apply Agent filesystem/process confinement for this run. */
+    workspaceAccess?: 'workspace' | 'full';
     temperature?: number;
     topP?: number;
     toolChoice?: ToolChoice;
@@ -905,6 +993,9 @@ export interface HadamardDreamConfig {
     minHours: number;
     minSessions: number;
     scanIntervalMs: number;
+    minRolloutIdleHours?: number;
+    maxRolloutAgeDays?: number;
+    maxRolloutsPerStartup?: number;
 }
 export interface HadamardDreamPaths {
     memoryDir: string;
@@ -913,6 +1004,10 @@ export interface HadamardDreamPaths {
     teamMemoryEntrypoint: string;
     transcriptDir: string;
     lockPath: string;
+    stateDbPath: string;
+    rawMemoriesPath: string;
+    rolloutSummariesDir: string;
+    memorySummaryPath: string;
 }
 export interface HadamardDreamState {
     enabled: boolean;
@@ -925,8 +1020,12 @@ export interface HadamardDreamState {
     hoursSinceLastConsolidated: number;
     sessionsSinceLastConsolidated: string[];
     lockHeld: boolean;
+    eligibleRolloutCount?: number;
+    phase?: 'idle' | 'extracting' | 'consolidating';
+    leaseExpiresAt?: string;
+    lastError?: string;
     canRun: boolean;
-    blockedReason?: 'disabled' | 'time_gate' | 'session_gate' | 'locked' | 'scan_throttled';
+    blockedReason?: 'disabled' | 'time_gate' | 'session_gate' | 'locked' | 'scan_throttled' | 'missing_execution_profile';
 }
 export interface HadamardDreamRunOptions {
     force?: boolean;
@@ -934,6 +1033,7 @@ export interface HadamardDreamRunOptions {
     currentSessionId?: string;
     extraContext?: string;
     model?: string;
+    executionProfile?: import('./config/projectSettings.js').DreamExecutionProfileRef;
     maxTokens?: number;
     signal?: AbortSignal;
 }
@@ -970,6 +1070,12 @@ export interface HadamardSessionCompactResult {
     consecutiveFailures?: number;
     error?: string;
     state: HadamardSessionMemoryRuntimeState;
+    budget?: {
+        rawContextWindowTokens: number;
+        effectiveContextWindowTokens: number;
+        autoCompactTokenLimit: number;
+        source: 'explicit' | 'derived' | 'fallback';
+    };
 }
 export interface HadamardTaskToolInput {
     description?: string;
@@ -1659,40 +1765,6 @@ export interface HadamardMemoryPaths {
     teamMemoryDir: string;
     teamMemoryEntrypoint: string;
     sessionId?: string;
-    sessionMemoryDir?: string;
-    sessionMemoryPath?: string;
-}
-export interface HadamardSessionMemoryState {
-    exists: boolean;
-    path?: string;
-    content?: string;
-    isEmpty?: boolean;
-    tokenEstimate?: number;
-    truncatedContent?: string;
-    wasTruncated?: boolean;
-}
-export interface HadamardSessionMemoryConfig {
-    minimumMessageTokensToInit: number;
-    minimumTokensBetweenUpdate: number;
-    toolCallsBetweenUpdates: number;
-}
-export interface HadamardSessionMemoryCompactConfig {
-    minTokens: number;
-    minTextBlockMessages: number;
-    maxTokens: number;
-}
-export interface HadamardSessionMemoryProgress {
-    currentTokenCount?: number;
-    tokensAtLastExtraction?: number;
-    tokensSinceLastExtraction?: number;
-    messageCountSinceLastExtraction?: number;
-    toolCallsSinceLastUpdate?: number;
-    initialized: boolean;
-    meetsInitializationThreshold?: boolean;
-    meetsUpdateThreshold?: boolean;
-    meetsToolCallThreshold?: boolean;
-    hasToolCallsInLastTurn?: boolean;
-    shouldExtract?: boolean;
 }
 export interface HadamardSessionMemoryRuntimeState {
     initialized: boolean;
@@ -1705,31 +1777,18 @@ export interface HadamardSessionMemoryRuntimeState {
     lastError?: string;
     pendingPostCompaction: boolean;
 }
-export interface AgentSessionMemoryExtractionOptions {
-    force?: boolean;
-    model?: string;
-    maxTokens?: number;
-    signal?: AbortSignal;
-}
 export interface AgentSessionDreamOptions extends HadamardDreamRunOptions {
 }
-export interface HadamardSessionMemoryExtractionResult {
-    success: boolean;
-    skipped: boolean;
-    updated: boolean;
-    trigger: 'auto' | 'manual';
-    reason?: string;
-    sessionId?: string;
-    memoryPath?: string;
-    summary?: string;
-    usage?: Usage;
-    state: HadamardSessionMemoryRuntimeState;
-}
 export interface HadamardMemoryOptions {
     configPath?: string;
     homeDir?: string;
     projectPath?: string;
     sessionId?: string;
+    enabledOverrides?: Partial<{
+        autoCompact: boolean;
+        autoMemory: boolean;
+        autoDream: boolean;
+    }>;
 }
 export interface HadamardMemoryPromptOptions extends HadamardMemoryOptions {
     extraGuidelines?: string[];
@@ -1737,19 +1796,9 @@ export interface HadamardMemoryPromptOptions extends HadamardMemoryOptions {
 }
 export interface HadamardMemoryStateOptions extends HadamardMemoryPromptOptions {
     includeCombinedPrompt?: boolean;
-    includeSessionMemory?: boolean;
-    includeSessionTemplate?: boolean;
-    includeSessionPrompt?: boolean;
 }
 export interface HadamardCompactStateOptions extends HadamardMemoryStateOptions {
     includeBoundaries?: boolean;
-    includeSummaryMessage?: boolean;
-    currentTokenCount?: number;
-    tokensAtLastExtraction?: number;
-    initialized?: boolean;
-    hasToolCallsInLastTurn?: boolean;
-    messageCountSinceLastExtraction?: number;
-    toolCallsSinceLastUpdate?: number;
     runtimeState?: HadamardSessionMemoryRuntimeState;
 }
 export interface HadamardMemoryState {
@@ -1761,14 +1810,8 @@ export interface HadamardMemoryState {
     };
     paths: HadamardMemoryPaths;
     combinedPrompt?: string;
-    sessionMemory?: HadamardSessionMemoryState;
-    sessionTemplate?: string;
-    sessionPrompt?: string;
 }
 export interface HadamardCompactState extends HadamardMemoryState {
-    sessionMemoryConfig: HadamardSessionMemoryConfig;
-    sessionMemoryCompactConfig: HadamardSessionMemoryCompactConfig;
-    progress?: HadamardSessionMemoryProgress;
     runtimeState?: HadamardSessionMemoryRuntimeState;
     agentContinuity?: HadamardAgentContinuityState;
     invokedSkills?: HadamardInvokedSkillRecord[];
@@ -1785,8 +1828,8 @@ export interface HadamardCompactState extends HadamardMemoryState {
     lastSummarizedMessageUuid?: string;
     latestPreservedSegment?: HadamardPreservedSegment;
     latestBoundarySummary?: string;
-    canUseSessionMemoryCompaction: boolean;
     summaryMessage?: string;
+    estimatedConversationTokens?: number;
 }
 export interface HadamardMemoryFileHeader {
     filename: string;
@@ -2428,7 +2471,32 @@ export interface WorktreeInfo {
  * convergence (the `panel` capability). `panel` and `analysis` are retained as
  * backward-compatible aliases that route to the same engine.
  */
-export type ModelTeamMode = 'panel-analysis' | 'panel' | 'analysis' | 'reviewer' | 'executor-reviewer' | 'graph';
+export type ModelTeamMode = 'panel-analysis' | 'panel' | 'analysis' | 'reviewer' | 'executor-reviewer' | 'graph' | 'workflow';
+/**
+ * Unified typed reference to an execution target (reference model redesign).
+ * Schemas persist the reference, not a copied provider/baseURL/apiKey snapshot;
+ * runtime resolution expands a ref via `resolveTargetRef`
+ * (`src/manager/resolveTargetRef.ts`).
+ *
+ * There is deliberately no `router` kind: routers cannot be route/execution
+ * targets (nested classification chains and cycles are disallowed).
+ *
+ * For `{ kind: 'model' }`, an empty `config` string marks a "raw model ref":
+ * a legacy target whose originating bridge config is unknown — resolution then
+ * falls back to whatever legacy provider/baseURL/apiKey fields sit next to the
+ * ref (or to session defaults).
+ */
+export type AgentTargetRef = {
+    kind: 'model';
+    config: string;
+    model: string;
+} | {
+    kind: 'agent';
+    name: string;
+} | {
+    kind: 'team';
+    name: string;
+};
 /** A node in a workflow squad's execution tree. */
 export interface WorkflowNode {
     id: string;
@@ -2441,6 +2509,23 @@ export interface WorkflowNode {
     condition?: string;
     runtime?: string;
     model?: string;
+    /** Agent nodes: specialist system prompt (separate from the task `prompt`). */
+    systemPrompt?: string;
+    /** Agent nodes: core-tool whitelist. Absent → no tools (legacy workflow behavior). */
+    allowedTools?: string[];
+    /** Per-node run timeout (ms). Omit → squad default. */
+    timeoutMs?: number;
+    /** Per-node ReAct tool-iteration cap. Omit or ≤0 = unlimited. */
+    maxIterations?: number;
+    /** `workspace` (default): project workspace only; `full`: unrestricted filesystem. */
+    workspaceAccess?: 'workspace' | 'full';
+    /**
+     * Typed reference to this agent node's executor (saved agent profile, team,
+     * or config-scoped model). When present, runtime resolution prefers it over
+     * the legacy inline `model` field. Absent on legacy nodes — lazy migration
+     * only fills it when the target is clearly resolvable.
+     */
+    targetRef?: AgentTargetRef;
     /** Children: branch=[if,else], parallel=all, agent=[] or one sequential continuation. */
     children: WorkflowNode[];
 }
@@ -2474,6 +2559,14 @@ export interface TeamMember {
      * `full`: unrestricted filesystem access (same as the main agent).
      */
     workspaceAccess?: 'workspace' | 'full';
+    /**
+     * Typed reference to this member's execution target (saved agent profile or
+     * config-scoped model). Runtime resolution prefers it over the legacy
+     * by-value model fields when present.
+     */
+    targetRef?: AgentTargetRef;
+    /** Core-tool whitelist for this member. Absent → the squad's default toolset. */
+    allowedTools?: string[];
 }
 export interface TeamReviewEdge {
     /** Reviewer member id/name/role. */
@@ -2515,6 +2608,14 @@ export interface TeamGraphNode extends Omit<TeamMember, 'model'> {
     type?: 'react' | 'single' | 'team';
     /** When `type === 'team'`, name of the persisted team definition to invoke. */
     teamRef?: string;
+    /**
+     * Typed reference to this node's execution target. Lazy migration on load
+     * turns `type: 'team'` + `teamRef` into `{ kind: 'team', name: teamRef }`;
+     * nodes with only a raw `model` keep `targetRef` absent (the legacy by-value
+     * fields remain the fallback) since the originating config is not knowable.
+     * Runtime resolution prefers `targetRef` when present.
+     */
+    targetRef?: AgentTargetRef;
     /** Return ports only — `void` (return 0) or structured `payload`. */
     returnMode?: TeamGraphReturnMode;
     /** Return ports in `payload` mode — template for the structured return value. */
@@ -2628,9 +2729,10 @@ export interface TeamDefinition {
      * Squad kind — drives which editor the GUI shows. Absent → 'graph' (back-compat).
      * - `graph`: collaboration graph (Task → agents → Return), the existing editor.
      * - `workflow`: linear/tree work-flow node editor (Phase 3 — visual work tree).
-     * - `subagent`: a single configured agent (prompt + tools + workspace + runtime).
+     * - `agent`: a single configured agent (prompt + tools + workspace + runtime).
+     * - `subagent`: legacy alias of `agent` (still accepted when loading).
      */
-    squadType?: 'graph' | 'workflow' | 'subagent';
+    squadType?: 'graph' | 'workflow' | 'agent' | 'subagent';
     /** Workflow squad only: the execution tree. */
     workflowTree?: WorkflowNode;
     /** Panel members (panel-analysis / its `panel`+`analysis` aliases). */
@@ -2750,6 +2852,11 @@ export interface TeamAskOptions {
     context?: string;
     /** Working directory the team members operate over. */
     workDir?: string;
+    /** Hadamard data root input for personal Agents/configs/teams. */
+    homeDir?: string;
+    /** Caller model/client used by inherit-session-model Agent targets. */
+    model?: string;
+    modelApi?: ModelApi;
     /** Receives progress events as the team deliberates. */
     onEvent?: (event: TeamEvent) => void;
     /** Permission policy inherited by every member runtime. Defaults to `default`, never bypass. */
@@ -2764,6 +2871,8 @@ export interface TeamAskOptions {
      * appends its own ref before invoking the sub-team.
      */
     teamStack?: string[];
+    /** Maximum Graph/Workflow definitions allowed in one nested execution chain. Defaults to 16. */
+    maxTeamNestingDepth?: number;
 }
 export interface TeamResult {
     answer: string;
@@ -2806,6 +2915,10 @@ export interface GraphTeamResult extends TeamResult {
     /** Convergence loop rounds (v3 graphs with loop edges). */
     graphRounds?: number;
 }
+/** `workflow` mode result. It retains the common graph-era report/status shape for API compatibility. */
+export interface WorkflowTeamResult extends Omit<GraphTeamResult, 'mode'> {
+    mode: 'workflow';
+}
 /** @deprecated Runtime always returns {@link GraphTeamResult}. Kept for type compatibility. */
 export type ReviewerResult = GraphTeamResult & {
     report?: string;
@@ -2815,7 +2928,7 @@ export type ReviewerResult = GraphTeamResult & {
 export type AnalysisResult = GraphTeamResult & {
     rounds?: number;
 };
-export type ModelTeamResult = GraphTeamResult;
+export type ModelTeamResult = GraphTeamResult | WorkflowTeamResult;
 /** A model target: a model id plus optional per-target provider config. */
 export interface RouterModelRef {
     model: string;
@@ -2835,6 +2948,16 @@ export interface RouterRoute extends RouterModelRef {
     role?: string;
     /** Optional richer description of the specialist's strengths, for the leader to weigh. */
     description?: string;
+    /** Preferred effort for this route's run; omit to keep session/default effort. */
+    effort?: HadamardRunEffort;
+    /**
+     * Typed execution target for this route. Lazily migrated on load from the
+     * legacy by-value fields: a route whose role/name matches a saved agent
+     * profile becomes `{ kind: 'agent', name }`; a model-only route becomes
+     * `{ kind: 'model', config: '', model }` (empty config = raw legacy model
+     * ref). Saves always write `target` while keeping the legacy fields.
+     */
+    target?: AgentTargetRef;
 }
 /**
  * A router profile = a Leader/Dispatch configuration under `/model`. The
@@ -2848,10 +2971,18 @@ export interface RouterProfile {
     description?: string;
     /** The leader: classifies each turn and dispatches it to a specialist route. */
     routerModel: RouterModelRef;
+    /** Typed identity for the leader's model configuration. */
+    routerModelTarget?: AgentTargetRef;
     /** The specialist roster the leader dispatches among. */
     routes: RouterRoute[];
     /** Used when the leader matches no route. Defaults to the first route. */
     fallback?: RouterModelRef;
+    /**
+     * Typed fallback target (allows fallback to a saved agent). Lazily migrated
+     * on load from the legacy `fallback` model ref; `fallback` is kept as the
+     * legacy by-value copy for back-compat.
+     */
+    fallbackTarget?: AgentTargetRef;
     /** Optional custom leader/dispatch-prompt prefix. */
     classificationPrompt?: string;
 }
@@ -2865,6 +2996,8 @@ export interface RouterDecision {
     classification: string;
     /** Whether the classifier matched a configured route (vs fell back). */
     matched: boolean;
+    /** The matched route's preferred effort (routes only; fallback carries none). */
+    effort?: HadamardRunEffort;
 }
 export interface ModelPricing {
     input: number;