insika 0.8.0 → 1.0.1

data/lib/insika/studio/forms.rb

@@ -45,11 +45,36 @@ module Studio
       end
       smm = edge_int(r.params["steer_max_messages"], "steer_max_messages")
       smm.nil? ? limits.delete(:steer_max_messages) : limits[:steer_max_messages] = smm
+      # The debounce window is what makes `collect`/`steer` merge a burst AT THE
+      # DOOR; without it a steer agent only ever absorbs mid-run, at a tool
+      # boundary, and a turn that never calls one absorbs nothing. Same opt-in
+      # convention as above: blank DELETES, 0 = no window.
+      %w[debounce_ms debounce_max_ms].each do |field|
+        v = edge_int(r.params[field], field)
+        v.nil? ? limits.delete(field.to_sym) : limits[field.to_sym] = v
+      end
+      # Refused HERE (config time) and not at resolve time: a template without
+      # the placeholder drops the customer's message while the turn still looks
+      # steered — the same rule QueuePolicy#join! enforces, moved to where the
+      # operator is.
+      if (join = presence(r.params["steer_join"]))
+        unless join.include?(Insika::QueuePolicy::JOIN_PLACEHOLDER)
+          raise Insika::ValidationError,
+                "steer_join must contain #{Insika::QueuePolicy::JOIN_PLACEHOLDER}"
+        end
+
+        limits[:steer_join] = join
+      else
+        limits.delete(:steer_join)
+      end
+      model, provider = picked_model(r, model_ref_of(@agent.model, @agent.provider))
       {
         id: @agent.id,
-        model: presence(r.params["model"]),
-        provider: r.params["provider"].to_s,
+        model: model,
+        provider: provider.to_s,
         memory: r.params["memory"] == "1",
+        memory_retrieval: memory_retrieval_patch(r),
+        knowledge: knowledge_patch(r),
         limits: limits,
         params: params_patch(r),
         model_policy: model_policy_patch(r),
@@ -77,6 +102,7 @@ module Studio
         # unchecked box saves an explicit false — both spellings of ON collapse.
         tool_persistence: r.params["tool_persistence"] == "1",
         tool_output_compression: r.params["tool_output_compression"] == "1",
+        fencing: r.params["fencing"] == "1",
         subagents: list_patch(r, "subagents"),
         capabilities: list_patch(r, "capabilities"),
         tools_deferred: list_patch(r, "tools_deferred"),
@@ -84,11 +110,99 @@ module Studio
         context_providers: allowlist_patch(r, "context_providers"),
         workflows_allow: allowlist_patch(r, "workflows_allow"),
         approvals_required: list_patch(r, "approvals_required"),
+        customer_confirm: list_patch(r, "customer_confirm"),
         policies: list_patch(r, "policies").map(&:to_sym),
         prompt_refs: list_patch(r, "prompt_refs"),
         capabilities_declared: list_patch(r, "capabilities_declared"),
         skills_eager: skills_eager_patch(r)
-      }
+      }.merge(inherited_fields(r))
+    end
+
+    # The Studio picker posts `model_ref` (checked against the list; `kept` = the
+    # stored ref, allowed back unchanged). Without it, the plain `model`/`provider`
+    # pair passes as given (API clients, older forms). -> [model | nil, provider | nil]
+    def picked_model(r, kept = nil)
+      return model_ref_parts(r.params["model"], r.params["provider"]) unless r.params.key?("model_ref")
+
+      model_ref_parts(checked_model_ref(r.params["model_ref"], kept), nil)
+    end
+
+    # Any other model field the Studio renders as a picker posts "<field>_ref" (one
+    # ref) or "<field>_refs[]" (one per slot), checked like the agent model; `kept`
+    # (the stored value) may come back unchanged. The plain field passes as given.
+    def ref_param(r, field, kept)
+      key = "#{field}_ref"
+      r.params.key?(key) ? checked_model_ref(r.params[key], kept) : presence(r.params[field])
+    end
+
+    def ref_list_param(r, field, kept)
+      key = "#{field}_refs"
+      return list(r.params[field]) unless r.params.key?(key)
+
+      Array(r.params[key]).filter_map { |ref| checked_model_ref(ref, Array(kept)) }
+    end
+
+    # ONE ref, "provider/model" (an OpenRouter model keeps its own slash:
+    # "openrouter/deepseek/x"). A separate `provider` wins as given.
+    def model_ref_parts(ref, provider)
+      model = presence(ref)
+      return [model, presence(provider)] if model.nil? || !presence(provider).nil? || !model.include?("/")
+
+      provider, model = model.split("/", 2)
+      [model, provider]
+    end
+
+    # The sections whose "use the platform default" box is checked save nil, so
+    # the agent keeps inheriting (Insika::AgentDefaults).
+    def inherited_fields(r)
+      (Array(r.params["inherit"]) & Insika::AgentDefaults::FIELDS).to_h { |field| [field.to_sym, nil] }
+    end
+
+    # The platform agent defaults form: the same sections and parsers as the
+    # agent form, read against the current defaults (so pack-only keys survive).
+    def agent_defaults_patch(r)
+      @agent = agent_defaults_profile
+      Insika::AgentDefaults::FIELDS.to_h { |field| [field, public_send(:"#{field}_patch", r)] }
+    end
+
+    def memory_retrieval_patch(r)
+      rerank = retrieval_rerank_patch(r, "memory")
+      return nil unless rerank
+
+      { "top_k" => retrieval_top_k(r, "memory"), "rerank" => rerank }
+    end
+
+    def knowledge_patch(r)
+      # Preserve pack options the form does not expose, such as the index.
+      out = (@agent.knowledge || {}).except("extract", "retrieve", "top_k", "types", "model", "prompt", "rerank")
+      out.merge!("extract" => r.params["knowledge_extract"] == "1",
+                 "retrieve" => r.params["knowledge_retrieve"] == "1",
+                 "top_k" => retrieval_top_k(r, "knowledge"))
+      types = list(r.params["knowledge_types"])
+      out["types"] = types unless types.empty?
+      (m = ref_param(r, "knowledge_model", (@agent.knowledge || {})["model"])) && (out["model"] = m)
+      (p = presence(r.params["knowledge_prompt"])) && (out["prompt"] = p)
+      rerank = retrieval_rerank_patch(r, "knowledge")
+      out["rerank"] = rerank if rerank
+      out
+    end
+
+    def retrieval_top_k(r, source)
+      field = "#{source}_top_k"
+      value = edge_int(r.params[field], field) || 5
+      raise Insika::ValidationError, "#{field} must be positive" unless value.positive?
+
+      value
+    end
+
+    def retrieval_rerank_patch(r, source)
+      return nil unless r.params["#{source}_rerank_enabled"] == "1"
+
+      prefix = "#{source}_rerank"
+      { "provider" => presence(r.params["#{prefix}_provider"]),
+        "model" => presence(r.params["#{prefix}_model"]),
+        "candidate_limit" => edge_int(r.params["#{prefix}_candidate_limit"], "#{prefix}_candidate_limit") || 20,
+        "timeout_seconds" => edge_float(r.params["#{prefix}_timeout_seconds"], "#{prefix}_timeout_seconds") || 2 }
     end
 
     # grounding — { "mode" => "flag"|"enforce", "matcher" =>
@@ -161,7 +275,7 @@ module Studio
       enabled = r.params["distill_enabled"] == "1"
       out = { "enabled" => enabled }
       (p = presence(r.params["distill_prompt"])) && (out["prompt"] = p)
-      (m = presence(r.params["distill_model"])) && (out["model"] = m)
+      (m = ref_param(r, "distill_model", (@agent.distill || {})["model"])) && (out["model"] = m)
       %w[idle_hours min_messages max_proposals].each do |key|
         v = edge_int(r.params["distill_#{key}"], "distill_#{key}")
         out[key] = v unless v.nil?
@@ -188,7 +302,7 @@ module Studio
 
     def harvest_miner_patch(r)
       miner = {}
-      (m = presence(r.params["harvest_miner_model"])) && (miner["model"] = m)
+      (m = ref_param(r, "harvest_miner_model", (@agent.harvest || {}).dig("miner", "model"))) && (miner["model"] = m)
       window = {}
       (w = edge_int(r.params["harvest_miner_window"], "harvest_miner_window")) && (window["last_sessions"] = w)
       miner["window"] = window unless window.empty?
@@ -209,7 +323,7 @@ module Studio
       (f = edge_int(r.params["refinement_max_findings"], "refinement_max_findings")) && (out["max_findings"] = f)
       files = list(r.params["refinement_files"])
       out["files"] = files unless files.empty?
-      proposers = list(r.params["refinement_proposers"])
+      proposers = ref_list_param(r, "refinement_proposers", (@agent.refinement || {})["proposers"])
       out["proposers"] = proposers unless proposers.empty?
       (t = edge_int(r.params["refinement_budget_tokens"], "refinement_budget_tokens")) && (out["budget"] = { "tokens" => t })
       (e = edge_int(r.params["refinement_auto_apply_max_edits"], "refinement_auto_apply_max_edits")) && (out["auto_apply_max_edits"] = e)
@@ -236,7 +350,7 @@ module Studio
       retries = edge_int(r.params["reliability_retries"], "reliability_retries")
       backoff = presence(r.params["reliability_backoff"])
       timeout = edge_int(r.params["reliability_timeout"], "reliability_timeout")
-      fallback = list(r.params["reliability_fallback"])
+      fallback = ref_list_param(r, "reliability_fallback", (@agent.reliability || {})["fallback"])
       return nil if retries.nil? && backoff.nil? && timeout.nil? && fallback.empty?
 
       out = {}
@@ -327,7 +441,8 @@ module Studio
       out = {
         "input" => r.params["guardrail_input"] == "1",
         "output" => r.params["guardrail_output"] == "1",
-        "strictness" => presence(r.params["guardrail_strictness"]) || "medium"
+        "strictness" => presence(r.params["guardrail_strictness"]) || "medium",
+        "injection" => r.params["guardrail_injection"] == "block" ? "block" : "flag"
       }
       (mod = presence(r.params["guardrail_moderator"])) && (out["moderator"] = mod)
       responses = guardrail_responses_patch(r)
@@ -386,7 +501,7 @@ module Studio
     # record on write, so anything missing here is erased — a save that only fixed a
     # typo in the description would silently drop them (the class of bug already
     # paid for once). `stored` carries them through untouched.
-    UNEDITED_TOOL_FIELDS = %w[group tags halt_when].freeze
+    UNEDITED_TOOL_FIELDS = %w[group tags halt_when evidence presentation side_effect].freeze
 
     # :write_data_tool payload from the form. nested request/response;
     # headers/query as "key=value" per line (same idiom as the MCP env —
@@ -394,12 +509,17 @@ module Studio
     # `stored` = the definition being edited (nil when creating).
     def tool_patch(r, stored = nil)
       preserved = (stored || {}).slice(*UNEDITED_TOOL_FIELDS).compact
-      preserved.merge(
+      method = presence(r.params["method"]) || "GET"
+      # A stored side_effect describes the stored method. When the method changes
+      # (a GET turned POST) it is dropped so the store re-derives it — the write
+      # gate and the resume skip both read it.
+      preserved.delete("side_effect") unless method == (stored || {}).dig("request", "method")
+      patch = preserved.merge(
         name: presence(r.params["name"]),
         description: r.params["description"].to_s,
         parameters: parse_parameters(r.params["parameters"]),
         request: {
-          method: presence(r.params["method"]) || "GET",
+          method: method,
           url: r.params["url"].to_s,
           headers: parse_kv_lines(r.params["headers"]),
           query: parse_kv_lines(r.params["query"]),
@@ -410,8 +530,17 @@ module Studio
           path: presence(r.params["path"])
         },
         secret_headers: split_list(r.params["secret_headers"]),
+        requires_evidence: if r.params.key?("requires_evidence")
+                             split_list(r.params["requires_evidence"]).then { |names| names.empty? ? nil : names }
+                           else
+                             (stored || {})["requires_evidence"]
+                           end,
         timeout: presence(r.params["timeout"])
       )
+      # A presentation tool makes no request: the form's HTTP fields are blank and
+      # the definition refuses both halves at once.
+      patch.delete(:request) if preserved["presentation"]
+      patch
     end
 
     # Parameters, TWO accepted syntaxes in one field (auto-detected, no mode toggle):
@@ -447,6 +576,10 @@ module Studio
       end
     end
 
+    def stored_compaction_model
+      insika[:settings_store] ? insika[:settings_store].get.dig("compaction", "model") : nil
+    end
+
     def settings_patch(r)
       patch = {
         "streaming" => r.params["streaming"] == "1"
@@ -466,7 +599,7 @@ module Studio
       # when cleared (deep_merge — the defaults backstop a fresh record);
       # model blank = nil = the platform utility_model.
       compaction = { "enabled" => r.params["compaction_enabled"] == "1",
-                     "model" => presence(r.params["compaction_model"]) }
+                     "model" => ref_param(r, "compaction_model", stored_compaction_model) }
       %w[keep_last compact_after].each do |f|
         v = presence(r.params["compaction_#{f}"])
         compaction[f] = Integer(v) if v
@@ -488,6 +621,30 @@ module Studio
       { "edge" => edge }
     end
 
+    # Burst policy — the PLATFORM layer of the QueuePolicy, saved from its own form
+    # (a sub-resource, like edge/models). Every field writes nil when blank, and nil
+    # here means "no platform default" (QueuePolicy.pick skips it) — NOT 0, which on
+    # `steer_max_messages` would read as "never steer" deploy-wide. The two refusals
+    # are the agent form's, verbatim: an unknown mode and a `steer_join` that would
+    # drop the customer's message are config errors, caught where the operator is.
+    def queue_patch(r)
+      mode = presence(r.params["queue_mode"])
+      if mode && !Insika::QueuePolicy::MODES.map(&:to_s).include?(mode)
+        raise Insika::ValidationError, "queue_mode must be one of: #{Insika::QueuePolicy::MODES.join(', ')}"
+      end
+
+      join = presence(r.params["steer_join"])
+      if join && !join.include?(Insika::QueuePolicy::JOIN_PLACEHOLDER)
+        raise Insika::ValidationError, "steer_join must contain #{Insika::QueuePolicy::JOIN_PLACEHOLDER}"
+      end
+
+      queue = { "queue_mode" => mode, "steer_join" => join }
+      %w[debounce_ms debounce_max_ms steer_max_messages].each do |f|
+        queue[f] = edge_int(r.params[f], f)
+      end
+      { "queue" => queue }
+    end
+
     # An eval case arrives as the YAML text the operator edited — the same shape the
     # corpus files hold, so there is one format to learn and a pull request can review
     # what was authored. Decoding happens HERE, at the transport edge; the SHAPE is
@@ -558,7 +715,27 @@ module Studio
     # deep-merge writes and the ModelResolver reads as "no platform default");
     # fallback_models is a full-list replace (deep_merge substitutes arrays, so a
     # resubmit never accumulates).
+    # The pickers post `*_ref` fields, each checked against the list (a stored
+    # value may come back unchanged): default_model splits into model/provider like
+    # the agent's; fallback_refs[] is one picker per slot (blank slots dropped).
+    # Without them, the plain fields pass as given (API clients, older forms).
     def model_defaults_patch(r)
+      return plain_model_defaults(r) unless r.params.key?("default_model_ref")
+
+      current = insika[:settings_store] ? insika[:settings_store].get : {}
+      kept_default = model_ref_of(current["default_model"], current["default_provider"])
+      default_model, default_provider = model_ref_parts(checked_model_ref(r.params["default_model_ref"], kept_default), nil)
+      kept_fallbacks = Array(current["fallback_models"])
+      {
+        "default_model" => default_model,
+        "default_provider" => default_provider,
+        "utility_model" => checked_model_ref(r.params["utility_model_ref"], current["utility_model"]),
+        "fallback_models" => Array(r.params["fallback_refs"]).filter_map { |f| checked_model_ref(f, kept_fallbacks) },
+        "thinking" => presence(r.params["thinking"])
+      }
+    end
+
+    def plain_model_defaults(r)
       {
         "default_model" => presence(r.params["default_model"]),
         "default_provider" => presence(r.params["default_provider"]),

data/lib/insika/studio/nav_icons.rb

@@ -8,13 +8,16 @@ module Studio
     # 20×20 stroke icons (currentColor), one per nav key. Source: a Lucide-style
     # line icon set.
     NAV_ICONS = {
+      search: '<circle cx="11" cy="11" r="7"/><path d="m20 20-3.5-3.5"/>',
       home: '<path d="M3 9.5 12 3l9 6.5"/><path d="M5 10v10a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1V10"/><path d="M9 21v-6h6v6"/>',
       agents: '<path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M22 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/>',
       skills: '<path d="m12 3-1.9 5.8a2 2 0 0 1-1.3 1.3L3 12l5.8 1.9a2 2 0 0 1 1.3 1.3L12 21l1.9-5.8a2 2 0 0 1 1.3-1.3L21 12l-5.8-1.9a2 2 0 0 1-1.3-1.3z"/>',
+      kits: '<path d="M21 8 12 3 3 8v8l9 5 9-5z"/><path d="m3 8 9 5 9-5"/><path d="M12 13v8"/>',
       tools: '<path d="M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.77-3.77a6 6 0 0 1-7.94 7.94l-6.91 6.91a2.12 2.12 0 0 1-3-3l6.91-6.91a6 6 0 0 1 7.94-7.94l-3.76 3.76z"/>',
       system: '<path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><path d="M14 2v6h6"/><path d="M8 13h8"/><path d="M8 17h8"/>',
       mcp: '<rect x="3" y="3" width="7" height="7" rx="1"/><rect x="14" y="3" width="7" height="7" rx="1"/><rect x="14" y="14" width="7" height="7" rx="1"/><rect x="3" y="14" width="7" height="7" rx="1"/>',
       settings: '<path d="M20 7h-9"/><path d="M14 17H5"/><circle cx="17" cy="17" r="3"/><circle cx="7" cy="7" r="3"/>',
+      live: '<path d="M22 12h-4l-3 9L9 3l-3 9H2"/>',
       chats: '<path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"/>',
       playground: '<polygon points="6 3 20 12 6 21 6 3"/>',
       tasks: '<path d="M11 12H3"/><path d="M16 6H3"/><path d="M16 18H3"/><path d="m18 9 3 3-3 3"/>',

data/lib/insika/studio/views/_agent_config_retrieval.erb

@@ -0,0 +1,73 @@
+<% knowledge = @agent.knowledge || {} %>
+<p class="muted">Memory keeps facts and notes across conversations. Knowledge stores reusable concepts. Reranking only changes which saved information is selected for a turn.</p>
+<% [["memory", "Memory", @agent.memory_retrieval || {}], ["knowledge", "Knowledge", knowledge]].each do |source, title, config| %>
+  <fieldset class="subgroup">
+    <legend><%= title %></legend>
+    <%== inherit_toggle(source == "memory" ? "memory_retrieval" : "knowledge") %>
+    <% if source == "memory" %>
+      <% unless @agent_defaults_form %>
+      <label class="check own">
+        <input type="checkbox" name="memory" value="1"<%== " checked" if @agent.memory %>>
+        Remember across conversations
+      </label>
+      <% end %>
+      <p class="muted">Without reranking, memory uses saved facts and the ten most recent notes. Turning memory off does not delete them.</p>
+    <% else %>
+      <label class="check">
+        <input type="checkbox" name="knowledge_extract" value="1"<%== " checked" if Insika::Coercion.truthy?(knowledge["extract"]) %>>
+        Learn concepts from conversations
+      </label>
+      <label class="check">
+        <input type="checkbox" name="knowledge_retrieve" value="1"<%== " checked" if Insika::Coercion.truthy?(knowledge["retrieve"]) %>>
+        Use knowledge in replies
+      </label>
+      <p class="muted">Learning and retrieval work independently. Turning them off does not delete saved concepts.</p>
+      <label>Concepts selected per turn
+        <input type="number" name="knowledge_top_k" value="<%= knowledge.fetch("top_k", 5) %>" min="1" step="1">
+      </label>
+      <details class="newfile">
+        <summary>Knowledge learning settings</summary>
+        <div class="grid-2">
+          <label>Concept types <span class="muted">— comma-separated; blank = default types</span>
+            <input type="text" name="knowledge_types" value="<%= Array(knowledge["types"]).join(", ") %>" placeholder="fact, policy, objection">
+          </label>
+          <label>Learning model <span class="muted">— blank = platform utility model</span>
+            <%== model_select("knowledge_model_ref", knowledge["model"], "platform utility model") %>
+          </label>
+        </div>
+        <label>Learning instructions <span class="muted">— blank = default instructions</span>
+          <textarea name="knowledge_prompt" rows="4"><%= knowledge["prompt"] %></textarea>
+        </label>
+      </details>
+    <% end %>
+    <% rerank = config["rerank"] || {} %>
+    <label class="check">
+      <input type="checkbox" name="<%= source %>_rerank_enabled" value="1"<%== " checked" if config["rerank"] %>>
+      Rerank <%= source %> by relevance
+    </label>
+    <p class="muted">Off by default. Adds a provider call and may increase cost. Requires <%= source == "memory" ? "memory" : "knowledge retrieval" %> to be on. Provider credentials are configured separately.</p>
+    <details class="newfile"<%== " open" if config["rerank"] %>>
+      <summary><%= title %> rerank settings</summary>
+      <div class="grid-2">
+        <label>Rerank provider
+          <input type="text" name="<%= source %>_rerank_provider" value="<%= rerank["provider"] %>" placeholder="cohere">
+        </label>
+        <label>Rerank model
+          <input type="text" name="<%= source %>_rerank_model" value="<%= rerank["model"] %>" placeholder="rerank-v3.5">
+        </label>
+        <% if source == "memory" %>
+          <label>Memory items selected per turn
+            <input type="number" name="memory_top_k" value="<%= config.fetch("top_k", 5) %>" min="1" max="100" step="1">
+          </label>
+        <% end %>
+        <label>Candidate limit <span class="muted">— at least the selected count, up to 100</span>
+          <input type="number" name="<%= source %>_rerank_candidate_limit" value="<%= rerank.fetch("candidate_limit", 20) %>" min="1" max="100" step="1">
+        </label>
+        <label>Rerank timeout (seconds)
+          <input type="number" name="<%= source %>_rerank_timeout_seconds" value="<%= rerank.fetch("timeout_seconds", 2) %>" min="0.001" step="any">
+        </label>
+      </div>
+      <p class="muted">Choose a rerank model registered for this provider. On failure, the agent uses the usual retrieval. Disabling rerank clears these rerank settings.</p>
+    </details>
+  </fieldset>
+<% end %>

data/lib/insika/studio/views/_agent_picker.erb

@@ -0,0 +1,15 @@
+<%# Type-to-search agent picker: an <input list> over a <datalist> — native
+    search in every browser, no JS. Locals: name, options (ids), value,
+    blank (placeholder meaning "none / all"; nil = a value is required),
+    auto_submit (submit the form when a pick is committed). The server still
+    validates the value: a typed id that is not an agent is refused there. %>
+<%# unique per page: a page can carry two pickers (a filter and a form) %>
+<% list_id = "agent-options-#{name}-#{@agent_picker_seq = (@agent_picker_seq || 0) + 1}" %>
+<% blank = defined?(blank) ? blank : nil %>
+<% auto_submit = defined?(auto_submit) && auto_submit %>
+<input type="search" class="filter-input agent-picker" name="<%= name %>" list="<%= list_id %>" value="<%= value %>" autocomplete="off"
+       placeholder="<%= blank || "Type to search agents…" %>"<%== " required" unless blank %>
+       <%== %(data-controller="auto-submit" data-action="change->auto-submit#submit") if auto_submit %>>
+<datalist id="<%= list_id %>">
+  <% Array(options).each do |id| %><option value="<%= id %>"></option><% end %>
+</datalist>