turnkit 0.4.2 → 0.6.0

data/lib/turnkit/budget.rb

@@ -30,9 +30,9 @@ module TurnKit
     def seed!(turns:, tool_executions:)
       @mutex.synchronize do
         @iterations = Array(turns).sum { |turn| Turn.iterations_for(turn) }
-        completed = Array(tool_executions).select { |execution| %w[completed failed].include?(execution["status"]) && !execution.dig("error", "details", "budget_denied") }
-        @tool_executions = completed.length
-        completed.each { |execution| @tool_executions_by_name[execution.fetch("tool_name").to_s] += 1 }
+        reserved = Array(tool_executions).reject { |execution| execution["status"] == "cancelled" || execution.dig("error", "details", "budget_denied") }
+        @tool_executions = reserved.length
+        reserved.each { |execution| @tool_executions_by_name[execution.fetch("tool_name").to_s] += 1 }
         @cost = Array(turns).sum { |turn| turn["cost"].to_f }
       end
       self
@@ -74,6 +74,7 @@ module TurnKit
     def check!(depth:)
       raise BudgetError, "maximum sub-agent depth reached" if max_depth && depth > max_depth
       raise BudgetError, "turn timed out" if timeout && Clock.now >= root_started_at + timeout
+      raise BudgetError, "cost limit reached" if max_spend && @cost > max_spend
     end
 
     private

data/lib/turnkit/conversation.rb

@@ -20,6 +20,24 @@ module TurnKit
       append_message(role: "user", kind: "text", text: text, metadata: metadata)
     end
 
+    def subject_prompt
+      subject.respond_to?(:to_prompt) ? subject.to_prompt.to_s : metadata["turnkit_subject_prompt"].to_s
+    end
+
+    def send_message(destination, text, key:, principal: nil)
+      Authorization.authorize!(:send_message, principal: principal, source_conversation: id, destination_conversation: destination.respond_to?(:id) ? destination.id : destination)
+      Background.send_message(source: id, destination: destination.respond_to?(:id) ? destination.id : destination,
+        text: text, key: key, store: store, principal: principal)
+    end
+
+    def inbox
+      store.list_deliveries(destination_conversation_id: id)
+    end
+
+    def outbox
+      store.list_deliveries(source_conversation_id: id)
+    end
+
     def ask(text, async: false, **options)
       trigger = say(text)
       turn = build_turn(trigger_message_id: trigger.id, **options)
@@ -30,14 +48,18 @@ module TurnKit
       build_turn(trigger_message_id: trigger_message_id, model: model, budget: budget, parent_turn: parent_turn, parent_tool_execution: parent_tool_execution, root_turn_id: root_turn_id, depth: depth, agent: agent, thinking: thinking, compact: compact, output_schema: output_schema, prompt_mode: prompt_mode, on_event: on_event).run!
     end
 
-    def build_turn(trigger_message_id: nil, model: nil, budget: nil, parent_turn: nil, parent_tool_execution: nil, root_turn_id: nil, depth: 0, agent: self.agent, thinking: THINKING_UNSET, compact: nil, output_schema: nil, prompt_mode: nil, on_event: nil)
+    def build_turn(trigger_message_id: nil, model: nil, budget: nil, parent_turn: nil, parent_tool_execution: nil, root_turn_id: nil, depth: 0, agent: self.agent, thinking: THINKING_UNSET, compact: nil, output_schema: nil, prompt_mode: nil, on_event: nil, context: nil, principal: nil)
       snapshot = latest_message_sequence
       effective_thinking = thinking.equal?(THINKING_UNSET) ? agent.effective_thinking : Agent.normalize_thinking(thinking)
       options = { "trigger_message_id" => trigger_message_id }.compact
+      options["budget_limits"] = agent.budget_limits.transform_keys(&:to_s)
       options["thinking"] = effective_thinking
       options["compact"] = compact unless compact.nil?
       options["output_schema"] = output_schema || agent.output_schema if output_schema || agent.output_schema
       options["prompt_mode"] = prompt_mode.to_sym if prompt_mode
+      options["context"] = JSON.parse(JSON.generate(context || metadata["turnkit_context"] || {}))
+      principal ||= metadata["principal"]
+      options["principal"] = JSON.parse(JSON.generate(principal)) unless principal.nil?
       record = store.create_turn(
         "conversation_id" => id,
         "agent_name" => agent.name,

data/lib/turnkit/coordination_tools.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module TurnKit
+  # Opt-in tools: the application chooses which agents can address conversations.
+  class SendMessageTool < Tool
+    tool_name "send_message"
+    description "Send a durable message to a conversation and wake it when idle."
+    parameter :conversation_id, :string, required: true
+    parameter :text, :string, required: true
+
+    def call(conversation_id:, text:, context:)
+      Background.send_message(source: context.turn.conversation.id, destination: conversation_id,
+        text: text, key: "message:#{context.execution.id}", store: context.turn.store, source_turn_id: context.turn.id, principal: context.principal)
+    end
+  end
+
+  class LaunchAgentTool < Tool
+    tool_name "launch_agent"
+    description "Launch a configured sub-agent independently. Returns IDs immediately; optionally receive a completion message."
+    parameter :agent_name, :string, required: true
+    parameter :task, :string, required: true
+    parameter :callback, :boolean, required: false
+
+    def call(agent_name:, task:, callback: false, context:)
+      parent = context.turn
+      agent = parent.agent.sub_agents.find { |candidate| candidate.name == agent_name }
+      raise ToolError, "unknown sub-agent: #{agent_name}" unless agent
+      Authorization.authorize!(:launch_agent, principal: context.principal, turn: parent, agent: agent, arguments: { "task" => task, "callback" => callback })
+      Authorization.authorize!(:callback, principal: context.principal, turn: parent.id, destination_conversation: parent.conversation.id) if callback
+      TurnKit.resolve_agent(agent.name)
+      child = nil
+      parent.store.atomic do
+        existing = parent.store.list_turns(root_turn_id: parent.root_turn_id).find { |row| row["parent_tool_execution_id"] == context.execution.id }
+        if existing
+          child = existing
+        else
+          built = SubAgentTool.for(agent).build_child(task: task, context: context)
+          options = parent.store.load_turn(built.id).fetch("options")
+          options = options.merge("callback_conversation_id" => parent.conversation.id) if callback
+          child = parent.store.update_turn(built.id, submitted_at: Clock.now, options: options)
+        end
+      end
+      Background.enqueue(child.fetch("id"))
+      SubAgentTool.result(child)
+    end
+  end
+
+  class WaitTool < Tool
+    tool_name "wait_for"
+    description "Suspend this background turn until all listed turns finish. Releases the worker while waiting."
+    parameter :turn_ids, :array, required: true
+
+    def call(turn_ids:, context:)
+      raise ToolError, "wait_for requires a background turn" unless context.turn.background?
+      ids = Background.wait(context.turn, turn_ids)
+      return :waiting unless Background.ready?(context.turn.store, context.turn.id)
+
+      { "results" => ids.map { |id| SubAgentTool.result(context.turn.store.load_turn(id)) } }
+    end
+  end
+end

data/lib/turnkit/error.rb

@@ -2,12 +2,15 @@
 
 module TurnKit
   class Error < StandardError; end
+  class AuthorizationError < Error; end
   class BudgetError < Error; end
   class ConfigError < Error; end
   class CompactionError < Error; end
   class InputError < Error; end
   class ModelAccessError < ConfigError; end
+  class ModelError < Error; end
   class StoreError < Error; end
+  class LostClaim < Error; end
   class ToolError < Error; end
   class ToolValidationError < ToolError; end
 end

data/lib/turnkit/execution_store.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module TurnKit
+  # All writes made by an execution, including writes by tools and compaction,
+  # are fenced by the same root lock used to revoke its claim.
+  class ExecutionStore < SimpleDelegator
+    def initialize(store, turn_id:, token:, conversation_id:)
+      super(store)
+      @turn_id, @token, @conversation_id = turn_id, token, conversation_id
+    end
+
+    def atomic(_conversation_id = nil)
+      __getobj__.atomic(@conversation_id) do
+        raise LostClaim, "turn ownership was revoked" unless load_turn(@turn_id)["claim_token"] == @token
+
+        yield
+      end
+    end
+
+    %i[create_conversation append_message next_message_sequence create_turn update_turn
+       claim_turn create_tool_execution claim_tool_execution create_delivery update_delivery
+       create_wait].each do |method|
+      define_method(method) do |*args, **kwargs|
+        atomic { __getobj__.public_send(method, *args, **kwargs) }
+      end
+    end
+  end
+end

data/lib/turnkit/id.rb

@@ -6,6 +6,7 @@ module TurnKit
       conversation: "conv",
       message: "msg",
       turn: "turn",
+      delivery: "delivery",
       tool_execution: "tool"
     }.freeze
 

data/lib/turnkit/image_tool.rb

@@ -18,11 +18,21 @@ module TurnKit
         provider: self.class.provider,
         size: self.class.size,
         assume_model_exists: self.class.assume_model_exists,
+        input_images: input_images(**arguments),
+        mask: mask(**arguments),
         params: self.class.params || {},
         metadata: metadata(**arguments)
       ).to_h
     end
 
+    def input_images(**)
+      nil
+    end
+
+    def mask(**)
+      nil
+    end
+
     def metadata(**)
       {}
     end

data/lib/turnkit/job.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+gem "activejob", ">= 7.2"
+gem "activerecord", ">= 7.2"
+require "active_job"
+require "active_record"
+
+module TurnKit
+  class Job < ActiveJob::Base
+    def perform(turn_id = nil)
+      Background.perform(turn_id)
+    end
+  end
+
+  # Schedule with the application's existing recurring-job facility.
+  class ReconcileJob < ActiveJob::Base
+    def perform
+      Background.reconcile
+    end
+  end
+end

data/lib/turnkit/memory_store.rb

@@ -1,15 +1,40 @@
 # frozen_string_literal: true
 
+require "monitor"
+
 module TurnKit
   class MemoryStore < Store
     def initialize
-      @mutex = Mutex.new
+      @mutex = Monitor.new
       @conversations = {}
       @turns = {}
       @messages = {}
       @tool_executions = {}
+      @deliveries = {}
+      @delivery_keys = {}
+      @waits = {}
       @message_sequences = Hash.new(0)
+      @transaction_depth = 0
+    end
+
+    def atomic(_conversation_id)
+      @mutex.synchronize do
+        snapshot = Marshal.dump([@conversations, @turns, @messages, @tool_executions, @deliveries, @delivery_keys, @waits, @message_sequences]) if @transaction_depth.zero?
+        @transaction_depth += 1
+        committed = false
+        begin
+          result = yield
+          committed = true
+          result
+        ensure
+          @transaction_depth -= 1
+          if snapshot && !committed
+            @conversations, @turns, @messages, @tool_executions, @deliveries, @delivery_keys, @waits, @message_sequences = Marshal.load(snapshot)
+          end
+        end
+      end
     end
+    def atomic_graph(&block) = atomic(nil, &block)
 
     def create_conversation(attributes)
       record = Record.conversation(attributes)
@@ -89,6 +114,86 @@ module TurnKit
       end
     end
 
+    def list_submitted_turns(limit: nil)
+      @mutex.synchronize do
+        rows = @turns.values.select { |turn| turn["submitted_at"] }.sort_by { |turn| [ turn["created_at"].to_f, turn["id"] ] }
+        rows = rows.first(limit) if limit
+        rows.map { |turn| duplicate(turn) }
+      end
+    end
+
+    def list_actionable_turns(limit:)
+      @mutex.synchronize do
+        @turns.values.select { |turn| turn["submitted_at"] && %w[pending waiting running].include?(turn["status"]) }
+          .sort_by { |turn| [ turn["updated_at"].to_f, turn["id"] ] }.first(limit).map { |turn| duplicate(turn) }
+      end
+    end
+
+    def list_stale_inline_turns(before:, limit:)
+      @mutex.synchronize do
+        @turns.values.select { |row| !row["submitted_at"] && %w[pending running].include?(row["status"]) &&
+          (row["heartbeat_at"] || row["started_at"] || row["created_at"]) < before }
+          .sort_by { |row| [row["updated_at"].to_f, row["id"]] }.first(limit).map { |row| duplicate(row) }
+      end
+    end
+
+    def create_delivery(attributes)
+      record = Record.delivery(attributes)
+      @mutex.synchronize do
+        existing_id = @delivery_keys[record.fetch("key")]
+        if existing_id
+          existing = @deliveries.fetch(existing_id)
+          Record.assert_delivery_retry!(existing, record)
+          return duplicate(existing)
+        end
+
+        @deliveries[record.fetch("id")] = record
+        @delivery_keys[record.fetch("key")] = record.fetch("id")
+        duplicate(record)
+      end
+    end
+
+    def load_delivery(id)
+      @mutex.synchronize { duplicate(@deliveries.fetch(id)) }
+    end
+
+    def update_delivery(id, attributes)
+      attrs = Record.delivery_update(attributes)
+      @mutex.synchronize do
+        @deliveries.fetch(id).merge!(attrs)
+        duplicate(@deliveries.fetch(id))
+      end
+    end
+
+    def list_deliveries(source_conversation_id: nil, destination_conversation_id: nil, pending: false, limit: nil)
+      @mutex.synchronize do
+        rows = @deliveries.values
+        rows = rows.select { |row| row["source_conversation_id"] == source_conversation_id } if source_conversation_id
+        rows = rows.select { |row| row["destination_conversation_id"] == destination_conversation_id } if destination_conversation_id
+        rows = rows.select { |row| row["delivered_at"].nil? } if pending
+        rows = rows.sort_by { |row| [ row["created_at"].to_f, row["id"] ] }
+        rows = rows.first(limit) if limit
+        rows.map { |row| duplicate(row) }
+      end
+    end
+
+    def create_wait(turn_id:, target_turn_id:)
+      @mutex.synchronize do
+        wait = { "turn_id" => turn_id, "target_turn_id" => target_turn_id }
+        @waits[[ turn_id, target_turn_id ]] ||= wait
+        duplicate(@waits.fetch([ turn_id, target_turn_id ]))
+      end
+    end
+
+    def list_waits(turn_id: nil, target_turn_id: nil)
+      @mutex.synchronize do
+        rows = @waits.values
+        rows = rows.select { |row| row["turn_id"] == turn_id } if turn_id
+        rows = rows.select { |row| row["target_turn_id"] == target_turn_id } if target_turn_id
+        rows.map { |row| duplicate(row) }
+      end
+    end
+
     def create_tool_execution(attributes)
       record = Record.tool_execution(attributes)
 
@@ -100,10 +205,12 @@ module TurnKit
       @mutex.synchronize { duplicate(@tool_executions.fetch(id)) }
     end
 
-    def update_tool_execution(id, attributes)
-      attrs = Record.tool_execution_update(attributes)
+    def claim_tool_execution(id, from: "running", to: "completed", **attributes)
+      attrs = Record.tool_execution_update(attributes.merge(status: to))
       @mutex.synchronize do
         record = @tool_executions.fetch(id)
+        return nil unless record["status"] == from
+
         record.merge!(attrs.merge("updated_at" => Clock.now))
         duplicate(record)
       end
@@ -118,14 +225,6 @@ module TurnKit
       end
     end
 
-    def find_stale_turns(before:)
-      @mutex.synchronize do
-        @turns.values.select do |turn|
-          %w[pending running].include?(turn["status"]) && stale_anchor(turn) && stale_anchor(turn) < before
-        end.map { |turn| duplicate(turn) }
-      end
-    end
-
     private
       def stringify(hash)
         hash.transform_keys(&:to_s)
@@ -135,8 +234,5 @@ module TurnKit
         Marshal.load(Marshal.dump(value))
       end
 
-      def stale_anchor(turn)
-        turn["heartbeat_at"] || turn["started_at"] || turn["created_at"]
-      end
   end
 end

data/lib/turnkit/reconciliation.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module TurnKit
+  # Reconciles turns abandoned by a dead worker: atomically marks them stale,
+  # marks their unfinished tool executions interrupted, and appends synthetic
+  # error tool results so the persisted transcript stays structurally complete
+  # for continuation. Unknown effects are not replayed; Background separately
+  # retries tools whose integrations explicitly declare replay safety.
+  module Reconciliation
+    INTERRUPTED_MESSAGE = "Tool execution was interrupted before a result was recorded. " \
+      "It is unknown whether the operation ran; do not assume it did or did not."
+
+    module_function
+
+    def reconcile!(before:)
+      reconciled = TurnKit.store.reconcile_stale_turns(before: before)
+      reconciled.each do |turn|
+        emit("turn.stale", turn)
+        executions = interrupt_tool_executions(turn)
+        repair_transcript(turn, executions)
+      end
+      Background.reconcile(before: before) if TurnKit.store.list_actionable_turns(limit: 1).any?
+      reconciled
+    end
+
+    def interrupt_tool_executions(turn, store: TurnKit.store)
+      store.list_tool_executions(turn_id: turn.fetch("id")).map do |execution|
+        next execution unless %w[pending running].include?(execution.fetch("status"))
+
+        interrupted = store.claim_tool_execution(
+          execution.fetch("id"),
+          from: execution.fetch("status"),
+          to: "interrupted",
+          error: { "message" => "interrupted: worker terminated while the tool was executing" },
+          completed_at: Clock.now
+        )
+        next execution unless interrupted
+
+        emit("tool_call.interrupted", turn, id: interrupted.fetch("tool_call_id"), name: interrupted.fetch("tool_name"), tool_execution_id: interrupted.fetch("id"))
+        interrupted
+      end
+    end
+
+    def repair_transcript(turn, executions, store: TurnKit.store)
+      messages = store.list_messages(turn.fetch("conversation_id"))
+      resolved = messages
+        .select { |message| message["turn_id"] == turn.fetch("id") && message["kind"] == "tool_result" }
+        .flat_map { |message| message["content"].map { |part| part["tool_call_id"] } }
+
+      messages
+        .select { |message| message["turn_id"] == turn.fetch("id") && message["kind"] == "tool_call" }
+        .flat_map { |message| message["content"].select { |part| part["type"] == "tool_call" } }
+        .reject { |part| resolved.include?(part["id"]) }
+        .each do |part|
+          execution = executions.find { |candidate| candidate["tool_call_id"] == part["id"] }
+          known = execution && %w[completed failed cancelled].include?(execution["status"])
+          payload = known ? execution["result"] || execution["error"] : { "error" => true, "message" => INTERRUPTED_MESSAGE }
+          message = store.append_message(
+            "conversation_id" => turn.fetch("conversation_id"),
+            "turn_id" => turn.fetch("id"),
+            "role" => "tool",
+            "kind" => "tool_result",
+            "content" => [ { "type" => "tool_result", "tool_call_id" => part["id"], "text" => payload.to_json, "error" => !known || execution["status"] == "failed" } ],
+            "tool_execution_id" => execution&.fetch("id"),
+            "metadata" => { "tool_name" => part["name"], "interrupted" => !known }
+          )
+          emit("message.created", turn, message_id: message.fetch("id"), role: "tool", kind: "tool_result")
+        end
+    end
+
+    def emit(type, turn, payload = {})
+      TurnKit.on_event&.call(Event.new(type: type, turn_id: turn.fetch("id"), conversation_id: turn.fetch("conversation_id"), payload: payload))
+    end
+  end
+end

data/lib/turnkit/record.rb

@@ -2,10 +2,11 @@
 
 module TurnKit
   module Record
-    TURN_STATUSES = %w[pending running completed failed cancelled stale].freeze
-    TOOL_EXECUTION_STATUSES = %w[pending running completed failed cancelled].freeze
+    TURN_STATUSES = %w[pending waiting running completed failed cancelled stale].freeze
+    TOOL_EXECUTION_STATUSES = %w[pending running completed failed cancelled interrupted].freeze
 
-    TURN_UPDATE_KEYS = %w[status options usage cost error output_text output_data started_at heartbeat_at completed_at].freeze
+    TURN_UPDATE_KEYS = %w[status options usage cost error output_text output_data submitted_at claim_token started_at heartbeat_at completed_at].freeze
+    DELIVERY_UPDATE_KEYS = %w[message_id delivered_at].freeze
     TOOL_EXECUTION_UPDATE_KEYS = %w[status result error started_at completed_at].freeze
 
     module_function
@@ -13,11 +14,12 @@ module TurnKit
     def conversation(attributes)
       attrs = stringify(attributes)
       now = Clock.now
+      subject_type, subject_id = subject_pair(attrs["subject"])
       {
         "id" => attrs["id"] || Id.generate(:conversation),
         "agent_name" => attrs["agent_name"],
         "model" => attrs["model"],
-        "subject" => attrs["subject"],
+        "subject" => attrs["subject"] && { "type" => subject_type, "id" => subject_id }.compact,
         "metadata" => attrs["metadata"] || {},
         "created_at" => attrs["created_at"] || now,
         "updated_at" => attrs["updated_at"] || now
@@ -50,6 +52,8 @@ module TurnKit
         "error" => attrs["error"],
         "output_text" => attrs["output_text"],
         "output_data" => attrs["output_data"],
+        "submitted_at" => attrs["submitted_at"],
+        "claim_token" => attrs["claim_token"],
         "started_at" => attrs["started_at"],
         "heartbeat_at" => attrs["heartbeat_at"],
         "completed_at" => attrs["completed_at"],
@@ -58,6 +62,35 @@ module TurnKit
       }
     end
 
+    def delivery(attributes)
+      attrs = stringify(attributes)
+      {
+        "id" => attrs["id"] || Id.generate(:delivery),
+        "source_conversation_id" => attrs.fetch("source_conversation_id"),
+        "destination_conversation_id" => attrs.fetch("destination_conversation_id"),
+        "source_turn_id" => attrs["source_turn_id"],
+        "key" => attrs.fetch("key"),
+        "payload" => JSON.parse(JSON.generate(attrs["payload"] || {})),
+        "message_id" => attrs["message_id"],
+        "delivered_at" => attrs["delivered_at"],
+        "created_at" => attrs["created_at"] || Clock.now
+      }
+    end
+
+    def assert_delivery_retry!(existing, requested)
+      keys = %w[source_conversation_id destination_conversation_id source_turn_id payload]
+      unless existing.slice(*keys) == requested.slice(*keys)
+        raise ToolError, "delivery key is already used for a different message"
+      end
+    end
+
+    def delivery_update(attributes)
+      attrs = stringify(attributes)
+      unknown = attrs.keys - DELIVERY_UPDATE_KEYS
+      raise ArgumentError, "unknown delivery update attributes: #{unknown.join(", ")}" if unknown.any?
+      attrs
+    end
+
     def tool_execution(attributes)
       attrs = stringify(attributes)
       status = attrs["status"] || "pending"

data/lib/turnkit/run.rb

@@ -37,6 +37,21 @@ module TurnKit
       self
     end
 
+    def perform_later(callback: nil)
+      turn.perform_later(callback: callback)
+      self
+    end
+
+    def wait_for(*targets)
+      turn.wait_for(*targets)
+      self
+    end
+
+    def cancel!(descendants: :retain, principal: nil)
+      turn.cancel!(descendants: descendants, principal: principal)
+      self
+    end
+
     def reload
       turn.reload
       self

data/lib/turnkit/skill.rb

@@ -4,23 +4,24 @@ require "yaml"
 
 module TurnKit
   class Skill
-    attr_reader :key, :name, :description, :content
+    attr_reader :key, :name, :description, :content, :tools
 
-    def self.from_file(path, key: nil, name: nil, description: "")
+    def self.from_file(path, key: nil, name: nil, description: "", tools: [])
       content, metadata = parse_file(File.read(path))
       base = File.basename(path, File.extname(path))
-      new(key: key || base, name: name || metadata["name"] || base.tr("_-", " ").split.map(&:capitalize).join(" "), description: description.to_s.empty? ? metadata["description"].to_s : description, content: content)
+      new(key: key || base, name: name || metadata["name"] || base.tr("_-", " ").split.map(&:capitalize).join(" "), description: description.to_s.empty? ? metadata["description"].to_s : description, content: content, tools: tools)
     end
 
     def self.from_directory(path, pattern: "*.md")
       Dir.glob(File.join(path, pattern)).sort.map { |file| from_file(file) }
     end
 
-    def initialize(key:, name:, content:, description: "")
+    def initialize(key:, name:, content:, description: "", tools: [])
       @key = key.to_s
       @name = name.to_s
       @description = description.to_s
       @content = content.to_s
+      @tools = Array(tools).dup.freeze
       raise ArgumentError, "key is required" if @key.empty?
       raise ArgumentError, "name is required" if @name.empty?
       raise ArgumentError, "content is required" if @content.empty?