thoth-agents 0.12.0 → 0.13.0

package/dist/opencode/profile-runtime.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '@opencode/plugin';
+import type { OpenCodeDependencies } from './context';
+export declare function registerProfileRuntime(ctx: Plugin.Context, deps: OpenCodeDependencies): Promise<void>;

package/dist/opencode/profile-sessions.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from '@opencode/plugin';
+export type SessionProfileSelection = {
+    name: string;
+    projectDir: string;
+};
+/** Plugin-global storage; selections retain the owning project's identity. */
+export declare class SessionProfileSelections {
+    private readonly storage;
+    private readonly projectDir;
+    constructor(storage: Plugin.Context['storage'], projectDir: string);
+    private parse;
+    set(sessionID: string, name: string | undefined, projectDir?: string): Promise<void>;
+    /** Collect before mutating storage so pagination remains stable. */
+    all(): Promise<Array<SessionProfileSelection & {
+        sessionID: string;
+    }>>;
+    get(sessionID: string): Promise<SessionProfileSelection | undefined>;
+}

package/dist/opencode/profiles/editor.d.ts

@@ -0,0 +1,44 @@
+import { type ModelProfileStore } from './store.js';
+import { type NamedModelProfile, type ProfileRole, type ProfileScope, type RoleProfile } from './types.js';
+export type ProfileEntry = {
+    key: string;
+    name: string;
+    /** Undefined only for the read-only virtual default. */
+    scope?: ProfileScope;
+    agents: NamedModelProfile['agents'];
+    /** Original persisted snapshot; undefined for an unsaved draft. */
+    base?: NamedModelProfile;
+    shadowed: boolean;
+};
+/** null removes an override, restoring effective config inheritance. */
+export type RoleEdit = {
+    model?: string | null;
+    variant?: string | null;
+};
+export declare const isDraft: (entry: ProfileEntry) => boolean;
+export declare const isEntryDirty: (entry: ProfileEntry) => boolean;
+/**
+ * Draft-until-save editor. Use entries() again after reload/save/discard/rename/delete.
+ * Entries are working copies; file operations re-read and save rejects stale baselines.
+ * Session selection remains caller-owned, not persisted by this host-neutral editor.
+ */
+export declare class ModelProfileWorkspace {
+    readonly store: ModelProfileStore;
+    private current;
+    constructor(store: ModelProfileStore);
+    /** Refresh disk state while retaining dirty working copies and their original baselines. */
+    reload(): void;
+    entries(): ProfileEntry[];
+    pendingCount(): number;
+    valuesFor(entry: ProfileEntry, role: ProfileRole): RoleProfile;
+    private assertEditable;
+    private newName;
+    createDraft(source: ProfileEntry, name: string, scope: ProfileScope): ProfileEntry;
+    edit(entry: ProfileEntry, role: ProfileRole, edit: RoleEdit): void;
+    /** Materialize all effective roles. A concurrent same-profile edit requires reload. */
+    save(entry: ProfileEntry): string;
+    /** Drop a draft or revert an edit to the latest persisted value. */
+    discard(entry: ProfileEntry): void;
+    rename(entry: ProfileEntry, name: string): void;
+    delete(entry: ProfileEntry): void;
+}

package/dist/opencode/profiles/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Host-neutral OpenCode model profiles.
+ *
+ * Inject the effective role roster into ModelProfileStore; use resolve(sessionName)
+ * for selection and resolveRoleProfile for field-level inheritance. Persisted files
+ * never contain the virtual `default`. Warnings are returned by resolve, collected
+ * by read(scope, warnings), and optionally forwarded to the store's warn callback.
+ * Runtime reads tolerate bad files; mutations reject invalid files to avoid data loss.
+ *
+ * ModelProfileWorkspace owns drafts until save. Same-profile concurrent saves raise
+ * ProfileConflictError (code PROFILE_CONFLICT); discard then reload entries to retry.
+ * Store mutations re-read files and atomically replace each individual file, not a
+ * transaction across global/project files or a cross-process compare-and-swap lock.
+ */
+export * from './editor.js';
+export * from './resolver.js';
+export * from './store.js';
+export * from './types.js';

package/dist/opencode/profiles/resolver.d.ts

@@ -0,0 +1,12 @@
+import { type EffectiveRoster, type ModelEntry, type NamedModelProfile, type ProfileRole, type RoleProfile } from './types.js';
+/** Normalize the effective config's scalar/array models without changing fallback order. */
+export declare function configuredModelChain(config: EffectiveRoster[ProfileRole]): ModelEntry[];
+/** Resolve one layer as a pair, matching runtime scalar/array model semantics. */
+export declare function resolveModelPair(config: EffectiveRoster[ProfileRole], inherited?: RoleProfile): RoleProfile;
+/** Model overrides own their variant; variant-only overrides inherit the model. */
+export declare function resolveRoleProfile(role: ProfileRole, profile: NamedModelProfile, roster: EffectiveRoster): RoleProfile;
+export declare function defaultModelProfile(roster: EffectiveRoster): NamedModelProfile;
+/** Profile first; a model ID occurs at most once, even if its variant differs. */
+export declare function mergeProfileModelChain(profile: RoleProfile, configured: readonly ModelEntry[]): ModelEntry[];
+/** Native subagent input format. Undefined means no model could be resolved. */
+export declare function formatModelString(profile: RoleProfile): string | undefined;

package/dist/opencode/profiles/store.d.ts

@@ -0,0 +1,63 @@
+import { type EffectiveRoster, type ModelProfileSelection, type ModelProfilesDocument, type NamedModelProfile, type ProfileScope, type RoleProfile } from './types.js';
+export declare const DEFAULT_PROFILE = "default";
+export type ModelProfileStoreOptions = {
+    cwd: string;
+    configDir?: string;
+    homeDir?: string;
+    env?: Record<string, string | undefined>;
+    /** Injected effective thoth-agents.json roster, including shipped defaults. */
+    roster?: EffectiveRoster;
+    warn?: (message: string) => void;
+    paths?: {
+        global: string;
+        project: string;
+    };
+};
+export declare function modelProfilePaths(options: ModelProfileStoreOptions): {
+    global: string;
+    project: string;
+};
+export declare function validateProfileName(value: unknown, writable?: boolean): string;
+export declare function parseRoleProfile(value: unknown): RoleProfile;
+export declare function parseNamedModelProfile(value: unknown): NamedModelProfile;
+/** Strict parser for editors; runtime readers catch errors and warn instead. */
+export declare function parseModelProfilesDocument(raw: unknown): ModelProfilesDocument;
+/** Identifiable optimistic-concurrency failure for RPC/TUI reload prompts. */
+export declare class ProfileConflictError extends Error {
+    readonly scope: ProfileScope;
+    readonly profileName: string;
+    readonly code = "PROFILE_CONFLICT";
+    constructor(scope: ProfileScope, profileName: string);
+}
+/** Synchronous, host-neutral file store. Runtime reads never throw for bad files. */
+export declare class ModelProfileStore {
+    private readonly options;
+    readonly paths: {
+        global: string;
+        project: string;
+    };
+    constructor(options: ModelProfileStoreOptions);
+    defaultProfile(): NamedModelProfile;
+    private load;
+    read(scope: ProfileScope, warnings?: string[]): ModelProfilesDocument;
+    lookup(name: string, scope?: ProfileScope): {
+        profile: NamedModelProfile;
+        scope?: ProfileScope;
+    } | undefined;
+    private write;
+    /** Re-read before writing. An expected baseline enables same-profile conflict detection. */
+    save(scope: ProfileScope, name: string, value: unknown, options?: {
+        expected?: NamedModelProfile | null;
+    }): void;
+    create(scope: ProfileScope, name: string, value: unknown): void;
+    /** Pins that actually resolved to a global profile follow rename/delete. */
+    private projectPointsToGlobal;
+    rename(scope: ProfileScope, source: string, target: string): void;
+    delete(scope: ProfileScope, name: string): {
+        clearedActive: boolean;
+    };
+    setActive(scope: ProfileScope, name?: string): void;
+    setGlobalActive(name?: string): void;
+    setProjectPin(name?: string): void;
+    resolve(sessionSelection?: string): ModelProfileSelection;
+}

package/dist/opencode/profiles/types.d.ts

@@ -0,0 +1,26 @@
+import type { AgentOverrideConfig, ModelEntry } from '../../config/schema.js';
+/** Shared canonical roster; never maintain a second role list here. */
+export declare const PROFILE_ROLES: ("orchestrator" | "explorer" | "librarian" | "oracle" | "designer" | "worker")[];
+export type ProfileRole = (typeof PROFILE_ROLES)[number];
+export type ProfileScope = 'global' | 'project';
+export type RoleProfile = {
+    model?: string;
+    variant?: string;
+};
+export type NamedModelProfile = {
+    agents: Partial<Record<ProfileRole, RoleProfile>>;
+};
+export type ModelProfilesDocument = {
+    version: 1;
+    active?: string;
+    profiles: Record<string, NamedModelProfile>;
+};
+/** Already includes shipped defaults. No runtime or host objects are required. */
+export type EffectiveRoster = Partial<Record<ProfileRole, Pick<AgentOverrideConfig, 'model' | 'variant'>>>;
+export type ModelProfileSelection = {
+    name: string;
+    scope?: ProfileScope;
+    profile: NamedModelProfile;
+    warnings: string[];
+};
+export type { ModelEntry };

package/dist/opencode/tool-overrides/evaluator.d.ts

@@ -0,0 +1,13 @@
+import type { PermissionRule } from '../permission-rules.js';
+import type { ActionOverride, EffectiveToolOverrides, ToolEffect, ToolScope } from './types.js';
+/** Rules to append to the shipped array; an empty override list is a no-op. */
+export declare function appendOverrideRules(overrides: readonly ActionOverride[]): PermissionRule[];
+/** Role-level preview at resource '*'; session rules are intentionally not involved. */
+export declare function evaluateAction(base: readonly PermissionRule[], effective: EffectiveToolOverrides | undefined, action: string, platform?: string): {
+    effect: ToolEffect;
+    origin: 'default' | ToolScope;
+};
+/** Inherit removes every exact entry, leaving broader patterns intact. */
+export declare function removeActionOverride(overrides: readonly ActionOverride[], action: string): ActionOverride[];
+/** Explicit choices go last so broader patterns cannot supersede the edit. */
+export declare function setActionOverride(overrides: readonly ActionOverride[], value: ActionOverride): ActionOverride[];

package/dist/opencode/tool-overrides/index.d.ts

@@ -0,0 +1,5 @@
+export { appendOverrideRules, evaluateAction, removeActionOverride, setActionOverride, } from './evaluator.js';
+export { ToolsConflictError, ToolsOverrideStore, type ToolsOverrideStoreOptions, toolsOverridePaths, } from './store.js';
+export * from './types.js';
+export { parseActionOverrides, parseToolsDocument, validateSpecialistRole, } from './validation.js';
+export { countActionMatches, matchAction } from './wildcard.js';

package/dist/opencode/tool-overrides/store.d.ts

@@ -0,0 +1,38 @@
+import { type SpecialistRole, type ToolScope, type ToolsRevision, type ToolsSnapshot, type ToolsState } from './types.js';
+export type ToolsOverrideStoreOptions = {
+    cwd: string;
+    configDir?: string;
+    homeDir?: string;
+    env?: Record<string, string | undefined>;
+    paths?: {
+        global: string;
+        project: string;
+    };
+    warn?: (message: string) => void;
+};
+export declare function toolsOverridePaths(options: ToolsOverrideStoreOptions): {
+    global: string;
+    project: string;
+};
+export declare class ToolsConflictError extends Error {
+    readonly scope: ToolScope;
+    readonly code = "TOOLS_CONFLICT";
+    constructor(scope: ToolScope);
+}
+/** Synchronous host-neutral store with per-file optimistic revisions. */
+export declare class ToolsOverrideStore {
+    private readonly options;
+    readonly paths: {
+        global: string;
+        project: string;
+    };
+    constructor(options: ToolsOverrideStoreOptions);
+    private raw;
+    read(scope: ToolScope): ToolsSnapshot;
+    resolve(): ToolsState;
+    private mutate;
+    /** Save ordered rules losslessly, including duplicates; other roles survive. */
+    save(scope: ToolScope, role: SpecialistRole, overrides: unknown, baseRevision: ToolsRevision): ToolsSnapshot;
+    /** Remove a scope's role entry (project reset resumes global inheritance). */
+    reset(scope: ToolScope, role: SpecialistRole, baseRevision: ToolsRevision): ToolsSnapshot;
+}

package/dist/opencode/tool-overrides/types.d.ts

@@ -0,0 +1,32 @@
+import { type ProfileRole } from '../profiles/types.js';
+export type SpecialistRole = Exclude<ProfileRole, 'orchestrator'>;
+export declare const SPECIALIST_ROLES: SpecialistRole[];
+export type ToolScope = 'global' | 'project';
+export type ToolEffect = 'allow' | 'ask' | 'deny';
+export type ActionOverride = {
+    action: string;
+    effect: ToolEffect;
+};
+export type RoleToolOverrides = {
+    overrides: ActionOverride[];
+};
+export type ToolsDocument = {
+    version: 1;
+    roles: Partial<Record<SpecialistRole, RoleToolOverrides>>;
+};
+export type EffectiveToolOverrides = RoleToolOverrides & {
+    origin: ToolScope;
+};
+/** Opaque token for the entire on-disk file, including invalid content. */
+export type ToolsRevision = string;
+export type ToolsSnapshot = {
+    document: ToolsDocument;
+    revision: ToolsRevision;
+    warnings: string[];
+};
+export type ToolsState = {
+    global: ToolsSnapshot;
+    project: ToolsSnapshot;
+    effective: Partial<Record<SpecialistRole, EffectiveToolOverrides>>;
+    warnings: string[];
+};

package/dist/opencode/tool-overrides/validation.d.ts

@@ -0,0 +1,5 @@
+import { type ActionOverride, type SpecialistRole, type ToolsDocument } from './types.js';
+export declare function parseActionOverrides(value: unknown): ActionOverride[];
+export declare function validateSpecialistRole(role: string): SpecialistRole;
+/** Unknown roles warn and are ignored; malformed known roles invalidate the file. */
+export declare function parseToolsDocument(value: unknown, warnings?: string[]): ToolsDocument;

package/dist/opencode/tool-overrides/wildcard.d.ts

@@ -0,0 +1,3 @@
+/** Mirrors OpenCode 2.2.5 wildcard.ts at 9bbb8ce18c80f099e0e448775f59d965ead40a21. */
+export declare function matchAction(input: string, pattern: string, platform?: string): boolean;
+export declare function countActionMatches(pattern: string, actions: readonly string[], platform?: string): number;

package/dist/opencode/tool-rpc-handlers.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '@opencode/plugin';
+import type { OpenCodeDependencies } from './context';
+export declare function registerToolRpc(ctx: Plugin.Context, deps: OpenCodeDependencies): Promise<void>;