@things-factory/ai-assistant 10.1.154 → 10.1.156

package/client/settings/agent-settings-model.ts

@@ -0,0 +1,164 @@
+/**
+ * What the AI agent card shows and sends, apart from how it draws (design/ai/agent-settings.md §7).
+ *
+ * Every action on the card - pick the default, turn an agent off, edit one, delete one, answer an inherited agent with
+ * this domain's key - is saved as the domain's whole agent list, so the server checks it as one write.
+ */
+export interface AgentDomain {
+  id: string
+  name: string
+}
+
+export interface AgentView {
+  id: string
+  name: string
+  provider: string
+  model: string
+  baseURL?: string | null
+  organization?: string | null
+  active: boolean
+  owner: AgentDomain
+  inherited: boolean
+  turnedOff: boolean
+  keyState: 'own' | 'inherited' | 'overridden' | 'missing'
+  keyDomain?: AgentDomain | null
+  keyHint?: string | null
+  usable: boolean
+  isDefault: boolean
+  usedBelow: AgentDomain[]
+}
+
+export interface AgentSettings {
+  chain: AgentDomain[]
+  agents: AgentView[]
+  defaultAgentId?: string | null
+  defaultFrom: 'own' | 'inherited' | 'first' | 'none'
+  state: string
+  reason?: string | null
+}
+
+export interface AgentDraft {
+  id?: string
+  name: string
+  provider: string
+  model: string
+  baseURL: string
+  organization: string
+  active: boolean
+  /** A new key. Empty keeps the stored one. */
+  apiKey: string
+}
+
+export type SaveChange =
+  | { kind: 'default'; agentId: string }
+  | { kind: 'turn-off'; agentId: string; off: boolean }
+  | { kind: 'active'; agentId: string; active: boolean }
+  | { kind: 'delete'; agentId: string }
+  | { kind: 'upsert'; draft: AgentDraft }
+  | { kind: 'key-override'; agentId: string; apiKey: string }
+  | { kind: 'key-clear'; agentId: string }
+
+export function draftOf(agent?: AgentView): AgentDraft {
+  return {
+    ...(agent && { id: agent.id }),
+    name: agent?.name ?? '',
+    provider: agent?.provider ?? 'openai',
+    model: agent?.model ?? '',
+    baseURL: agent?.baseURL ?? '',
+    organization: agent?.organization ?? '',
+    active: agent?.active ?? true,
+    apiKey: ''
+  }
+}
+
+export interface AgentGroup {
+  ownerId: string
+  inherited: boolean
+  /** The owner's place: `그룹 › 본사` when there is more than one domain above, else its name. */
+  path: string
+  agents: AgentView[]
+}
+
+/** This domain's own agents first, then each domain above, closest first. A domain with no agents has no group. */
+export function groupByOwner(settings: AgentSettings): AgentGroup[] {
+  const groups: AgentGroup[] = []
+  const above = settings.chain.length - 1
+  for (const [index, domain] of settings.chain.entries()) {
+    const agents = settings.agents.filter(one => one.owner.id === domain.id)
+    if (!agents.length && index > 0) continue
+    const path =
+      above > 1
+        ? settings.chain
+            .slice(index)
+            .reverse()
+            .map(one => one.name)
+            .join(' › ')
+        : domain.name
+    groups.push({ ownerId: domain.id, inherited: index > 0, path, agents })
+  }
+  return groups
+}
+
+/** The whole save for one action on the card. */
+export function saveInput(settings: AgentSettings, change: SaveChange) {
+  let agents = settings.agents
+    .filter(one => !one.inherited)
+    .map(one => ({
+      id: one.id,
+      name: one.name,
+      provider: one.provider,
+      model: one.model,
+      ...(one.baseURL && { baseURL: one.baseURL }),
+      ...(one.organization && { organization: one.organization }),
+      active: one.active
+    })) as Array<Record<string, any>>
+  /* Only this domain's own choice is written - an inherited or a first-by-name default is not pinned here. */
+  let defaultAgentId = settings.defaultFrom === 'own' ? settings.defaultAgentId ?? undefined : undefined
+  let turnedOff = settings.agents.filter(one => one.inherited && one.turnedOff).map(one => one.id)
+  let inheritedKeys: Array<{ agentId: string; apiKey?: string; clear?: boolean }> | undefined
+
+  switch (change.kind) {
+    case 'default':
+      defaultAgentId = change.agentId
+      break
+    case 'turn-off':
+      turnedOff = change.off ? [...new Set([...turnedOff, change.agentId])] : turnedOff.filter(id => id !== change.agentId)
+      if (change.off && defaultAgentId === change.agentId) defaultAgentId = undefined
+      break
+    case 'active':
+      agents = agents.map(one => (one.id === change.agentId ? { ...one, active: change.active } : one))
+      break
+    case 'delete':
+      agents = agents.filter(one => one.id !== change.agentId)
+      if (defaultAgentId === change.agentId) defaultAgentId = undefined
+      break
+    case 'upsert': {
+      const { draft } = change
+      const written = {
+        ...(draft.id && { id: draft.id }),
+        name: draft.name.trim(),
+        provider: draft.provider,
+        model: draft.model,
+        ...(draft.baseURL.trim() && { baseURL: draft.baseURL.trim() }),
+        ...(draft.provider === 'openai' && draft.organization.trim() && { organization: draft.organization.trim() }),
+        active: draft.active,
+        ...(draft.apiKey.trim() && { apiKey: draft.apiKey.trim() })
+      }
+      agents = draft.id ? agents.map(one => (one.id === draft.id ? written : one)) : [...agents, written]
+      break
+    }
+    case 'key-override':
+      inheritedKeys = [{ agentId: change.agentId, apiKey: change.apiKey }]
+      break
+    case 'key-clear':
+      inheritedKeys = [{ agentId: change.agentId, clear: true }]
+      break
+  }
+
+  return {
+    agents,
+    ...(defaultAgentId && { defaultAgentId }),
+    turnedOff,
+    ...(inheritedKeys && { inheritedKeys })
+  }
+}