Open Interpreter
从源码学会它怎么工作

   45  /// Product channel information used by branded package variants.
   46  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
   47  pub enum Product {
   48      Codex,
   49      OpenInterpreter,
   50  }
   51  
   52  impl Product {
   53      /// A binary shipped inside an Open Interpreter package is Open
   54      /// Interpreter unconditionally — identity must never depend on what the
   55      /// executable happens to be named or aliased to. The argv0 and env-var
   56      /// checks only exist for development builds run straight out of the
   57      /// cargo target directory.
   58      pub fn current() -> Self {
   59          if std::env::var_os(OPEN_INTERPRETER_BRAND_ENV_VAR).is_some()
   60              || is_open_interpreter_argv0()
   61              || is_open_interpreter_install()
   62          {
   63              Self::OpenInterpreter
   64          } else {
   65              Self::Codex
   66          }
   67      }
   68  
   69      pub fn display_name(self) -> &'static str {
   70          match self {
   71              Product::Codex => "OpenAI Codex",
   72              Product::OpenInterpreter => "Open Interpreter",
   73          }
   74      }
   75  
   76      pub fn command_name(self) -> &'static str {
   77          match self {
   78              Product::Codex => "codex",
   79              Product::OpenInterpreter => "interpreter",

   21  cd "${repo_root}"
   22  
   23  if [[ ! -d node_modules || ! -d sdk/typescript/node_modules ]]; then
   24    "${pnpm_command[@]}" install --frozen-lockfile --filter @openai/codex-sdk...
   25  fi
   26  
   27  "${pnpm_command[@]}" --filter @openai/codex-sdk run build
   28  
   29  CODEX_EXEC_PATH="${interpreter_bin}" "${pnpm_command[@]}" \
   30    --dir sdk/typescript \
   31    exec jest \
   32    --runInBand \
   33    tests/run.test.ts \
   34    --testNamePattern "resumes thread by id"
   35  
   36  echo "Codex SDK compatibility passed with ${interpreter_bin}"

   75  pub(crate) fn build_chat_harness_request(
   76      route: ChatHarnessRoute,
   77      turn: ChatHarnessTurn<'_>,
   78  ) -> Result<ChatHarnessRequest, CodexErr> {
   79      let ChatHarnessTurn {
   80          prompt,
   81          harness,
   82          harness_guidance,
   83          model_info,
   84          effort,
   85          thread_id,
   86          session_source,
   87      } = turn;
   88      let guided_prompt = prompt_with_harness_guidance(prompt, harness, harness_guidance);
   89      let yolo_mode = prompt
   90          .base_instructions
   91          .text
   92          .contains("Approval policy is currently never.");
   93      let (request_body, tool_kinds, title_request, postprocess) = match route {
   94          ChatHarnessRoute::DeepSeekTui => {
   95              let (request_body, tool_kinds) = build_deepseek_tui_request(&guided_prompt, model_info)
   96                  .map_err(|err| {
   97                      CodexErr::InvalidRequest(format!("invalid deepseek-tui request: {err}"))
   98                  })?;
   99              (request_body, tool_kinds, None, ChatHarnessPostprocess::None)
      … 121 lines omitted; exact range 75–231 …
  221              inject_mini_swe_agent_no_tool_call_format_error(stream)
  222          }
  223          ChatHarnessPostprocess::SweAgentActionCalls { has_submit_review } => {
  224              inject_swe_agent_action_calls(stream, has_submit_review)
  225          }
  226          ChatHarnessPostprocess::Terminus2ActionCalls {
  227              request_kind,
  228              pending_completion,
  229          } => inject_terminus_2_action_calls(stream, request_kind, pending_completion),
  230      }
  231  }

    1  pub(crate) mod claude_code;
    2  mod claude_code_prompt;
    3  pub(crate) mod deepseek_tui;
    4  pub(crate) mod guidance;
    5  pub(crate) mod kimi_cli;
    6  pub(crate) mod kimi_code;
    7  pub(crate) mod little_coder;
    8  pub(crate) mod mini_swe_agent;
    9  pub(crate) mod minimal;
   10  pub(crate) mod opencode;
   11  pub(crate) mod pi;
   12  pub(crate) mod qwen_code;
   13  pub(crate) mod request;
   14  pub(crate) mod routing;
   15  pub(crate) mod session_skills;
   16  pub(crate) mod swe_agent;
   17  pub(crate) mod terminus_2;
   18  pub(crate) mod zcode;

    8  #[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, JsonSchema, TS)]
    9  #[serde(rename_all = "lowercase")]
   10  #[ts(export_to = "v2/")]
   11  pub enum WireApiDto {
   12      Responses,
   13      Chat,
   14      Messages,
   15  }
   16  
   17  #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, JsonSchema, TS)]
   18  #[serde(rename_all = "camelCase")]
   19  #[ts(export_to = "v2/")]
   20  pub struct InterpreterProvider {
   21      pub id: String,
   22      pub name: String,
   23      pub description: String,
   24      pub is_current: bool,
   25      #[ts(optional)]
   26      pub base_url: Option<String>,
   27      #[ts(optional)]
   28      pub wire_api: Option<WireApiDto>,
   29      #[ts(optional)]
   30      pub env_key: Option<String>,
   31      pub configured: bool,
   32      pub is_default: bool,
      … 1 lines omitted; exact range 8–44 …
   34  
   35  #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, JsonSchema, TS)]
   36  #[serde(rename_all = "camelCase")]
   37  #[ts(export_to = "v2/")]
   38  pub struct InterpreterHarness {
   39      #[ts(optional)]
   40      pub id: Option<String>,
   41      pub label: String,
   42      pub description: String,
   43      pub is_recommended: bool,
   44  }

    5  #[derive(Debug, Clone, Copy, Eq, PartialEq)]
    6  pub(crate) enum MessagesHarnessRoute {
    7      ClaudeCode,
    8      ZCode,
    9  }
   10  
   11  /// Which claude-code tool/prompt surface a non-Messages wire should shape.
   12  ///
   13  /// `claude-code` and `claude-code-bare` share the same shaping primitives but
   14  /// differ in system prompt and tool set; this carries that distinction onto the
   15  /// Responses and Chat transports.
   16  #[derive(Debug, Clone, Copy, Eq, PartialEq)]
   17  pub(crate) enum ClaudeCodeProfileRoute {
   18      Full,
   19      Bare,
   20  }
   21  
   22  #[derive(Debug, Clone, Copy, Eq, PartialEq)]
   23  pub(crate) enum ChatHarnessRoute {
   24      DeepSeekTui,
   25      KimiCode,
   26      KimiCli,
   27      LittleCoder,
   28      MiniSweAgent,
   29      Minimal,
      … 111 lines omitted; exact range 5–151 …
  141          )),
  142          (WireApi::Messages, Harness::Native) => Err(CodexErr::InvalidRequest(
  143              "wire_api = \"messages\" requires a harness-native transport; configure harness = \"claude-code\" or \"claude-code-bare\" for Anthropic-style sessions"
  144                  .to_string(),
  145          )),
  146          (WireApi::Messages, Harness::Other(harness_name)) => Err(CodexErr::InvalidRequest(
  147              format!(
  148                  "wire_api = \"messages\" is not supported by harness = \"{harness_name}\""
  149              ),
  150          )),
  151      }

    1  //! The single integration point between the model client and
    2  //! chat-completions harness emulation.
    3  //!
    4  //! `client.rs` resolves a [`ChatHarnessRoute`] and calls
    5  //! [`build_chat_harness_request`]; everything harness-specific — guidance
    6  //! injection, per-harness request building, and response-stream
    7  //! postprocessing — lives here. Adding a chat harness means adding a route
    8  //! arm in this module, not editing the client.

   21      })];
   22      messages.extend(build_messages(prompt.get_formatted_input())?);
   23      let tools = build_tools();
   24      let tool_kinds = tools
   25          .iter()
   26          .filter_map(|tool| {
   27              tool.get("function")
   28                  .and_then(|function| function.get("name"))
   29                  .and_then(Value::as_str)
   30                  .map(|name| (name.to_string(), ToolOutputKind::Function))
   31          })
   32          .collect();
   33  
   34      Ok((
   35          json!({
   36              "model": model_info.slug,
   37              "messages": messages,
   38              "stream": true,
   39              "stream_options": {
   40                  "include_usage": true,
   41              },
   42              "store": false,
   43              "tools": tools,
   44              "thinking": {
   45                  "type": "enabled",
      … 64 lines omitted; exact range 21–120 …
  110                                      "text": message_content,
  111                                  }
  112                              ],
  113                          }));
  114                      }
  115                  }
  116                  "developer" => {}
  117                  _ => {}
  118              },
  119              ResponseItem::FunctionCall {
  120                  name,

  140  ///
  141  /// - If the model requests a function call, we execute it and send the output
  142  ///   back to the model in the next sampling request.
  143  /// - If the model sends only an assistant message, we record it in the
  144  ///   conversation history and consider the turn complete.
  145  ///
  146  pub(crate) async fn run_turn(
  147      sess: Arc<Session>,
  148      turn_context: Arc<TurnContext>,
  149      turn_extension_data: Arc<codex_extension_api::ExtensionData>,
  150      input: Vec<TurnInput>,
  151      prewarmed_client_session: Option<ModelClientSession>,
  152      cancellation_token: CancellationToken,
  153  ) -> CodexResult<Option<String>> {
  154      let mut client_session =
  155          prewarmed_client_session.unwrap_or_else(|| sess.services.model_client.new_session());
  156      // TODO(ccunningham): Pre-turn compaction runs before context updates and the
  157      // new user message are recorded. Estimate pending incoming items (context
  158      // diffs/full reinjection + user input) and trigger compaction preemptively
  159      // when they would push the thread over the compaction threshold.
  160      if let Err(err) = run_pre_sampling_compact(&sess, &turn_context, &mut client_session).await {
  161          if matches!(err, CodexErr::TurnAborted) {
  162              return Err(err);
  163          }
  164          let error = err.to_codex_protocol_error();
      … 53 lines omitted; exact range 140–228 …
  218          TurnDiffTracker::with_environment_display_roots(display_roots),
  219      ));
  220  
  221      // `ModelClientSession` is turn-scoped and caches WebSocket + sticky routing state, so we reuse
  222      // one instance across retries within this turn.
  223      // Pending input is drained into history before building the next model request.
  224      // However, we defer that drain until after sampling in two cases:
  225      // 1. At the start of a turn, so the fresh turn input in `input` gets sampled first.
  226      // 2. After auto-compact, when model/tool continuation needs to resume before any steer.
  227  
  228      let mut next_step_context = Some(first_step_context);

  243          let window_id = sess.current_window_id().await;
  244          super::rollout_budget::maybe_record_reminder(
  245              sess.as_ref(),
  246              turn_context.as_ref(),
  247              &window_id,
  248          )
  249          .await;
  250  
  251          // Capture once so context, advertised tools, and tool calls share one request view.
  252          let step_context = match next_step_context.take() {
  253              Some(step_context) => step_context,
  254              None => sess.capture_step_context(Arc::clone(&turn_context)).await,
  255          };
  256          let sampling_request_result: CodexResult<_> = async {
  257              super::time_reminder::maybe_record_current_time_reminder(
  258                  sess.as_ref(),
  259                  turn_context.as_ref(),
  260                  &window_id,
  261              )
  262              .await?;
  263  
  264              world_state = sess
  265                  .record_step_world_state_if_changed(&world_state, step_context.as_ref())
  266                  .await;
  267  
      … 14 lines omitted; exact range 243–292 …
  282              run_sampling_request(
  283                  Arc::clone(&sess),
  284                  Arc::clone(&step_context),
  285                  Arc::clone(&turn_extension_data),
  286                  Arc::clone(&turn_diff_tracker),
  287                  &mut client_session,
  288                  &responses_metadata,
  289                  sampling_request_input,
  290                  cancellation_token.child_token(),
  291              )
  292              .await

  240      let mut seen_tool_names = HashSet::new();
  241      for runtime in &runtimes {
  242          let tool_name = runtime.tool_name();
  243          if !seen_tool_names.insert(tool_name.clone()) {
  244              continue;
  245          }
  246          let exposure = runtime.exposure();
  247          if exposure.is_direct() && !is_hidden_by_code_mode_only(turn_context, &tool_name, exposure)
  248          {
  249              let spec = runtime.spec();
  250              specs.push(spec_for_model_request(
  251                  turn_context,
  252                  exposure,
  253                  &tool_name,
  254                  spec,
  255              ));
  256          }
  257      }
  258      specs.extend(hosted_specs);
  259  
  260      let registry = ToolRegistry::from_tools(runtimes);
  261      let model_visible_specs = merge_into_namespaces(specs)
  262          .into_iter()
  263          .filter(|spec| {
  264              namespace_tools_enabled(turn_context) || !matches!(spec, ToolSpec::Namespace(_))
  265          })
  266          .collect();
  267  
  268      (model_visible_specs, registry)

  102  #[derive(Clone, Copy)]
  103  pub enum HarnessAliasHandler {
  104      Agent,
  105      Bash,
  106      BashLower,
  107      Read,
  108      ReadLower,
  109      ReadMediaFile,
  110      Write,
  111      WriteLower,
  112      Edit,
  113      EditLower,
  114      Glob,
  115      GlobLower,
  116      Grep,
  117      GrepLower,
  118      AskUserQuestion,
  119      TaskList,
  120      TaskOutput,
  121      TaskStop,
  122      ChecklistAdd,
  123      ChecklistList,
  124      ChecklistUpdate,
  125      ChecklistWrite,
  126      DeepSeekDiagnostics,
      … 117 lines omitted; exact range 102–254 …
  244              Self::DeepSeekToolSearch => handle_deepseek_tool_search(invocation).await,
  245              Self::DeepSeekWriteFile => handle_deepseek_write_file(invocation).await,
  246              Self::OpenCodeTask => handle_opencode_task(invocation).await,
  247              Self::OpenCodeTodoWrite => handle_opencode_todowrite(invocation).await,
  248              Self::ZCodeTodoRead => handle_zcode_todo_read(invocation).await,
  249              Self::ZCodeTodoWrite => handle_zcode_todo_write(invocation).await,
  250              Self::ZCodeEnterPlanMode => handle_zcode_enter_plan_mode(invocation).await,
  251              Self::ZCodeExitPlanMode => handle_zcode_exit_plan_mode(invocation).await,
  252              Self::ZCodeReadSessionContext => handle_zcode_read_session_context(invocation).await,
  253              Self::ZCodeSkill => handle_zcode_skill(invocation).await,
  254          }

 1749  #[derive(Deserialize)]
 1750  struct WriteArgs {
 1751      #[serde(alias = "file_path", alias = "filePath")]
 1752      path: String,
 1753      content: String,
 1754      #[serde(default)]
 1755      mode: Option<String>,
 1756  }
 1757  
 1758  #[derive(Clone, Copy)]
 1759  enum HarnessFileChangeStage<'a> {
 1760      Started,
 1761      Completed,
 1762      Failed(&'a str),
 1763  }
 1764  
 1765  fn harness_file_change(
 1766      path: &Path,
 1767      previous_content: Option<&str>,
 1768      updated_content: &str,
 1769  ) -> HashMap<PathBuf, FileChange> {
 1770      let change = match previous_content {
 1771          Some(previous_content) => FileChange::Update {
 1772              unified_diff: similar::TextDiff::from_lines(previous_content, updated_content)
 1773                  .unified_diff()
      … 37 lines omitted; exact range 1749–1821 …
 1811                  .emit_turn_item_started(&invocation.turn, &item)
 1812                  .await;
 1813          }
 1814          HarnessFileChangeStage::Completed | HarnessFileChangeStage::Failed(_) => {
 1815              invocation
 1816                  .session
 1817                  .emit_turn_item_completed(&invocation.turn, item)
 1818                  .await;
 1819          }
 1820      }
 1821  }

   42  pub(crate) struct ToolCallRuntime {
   43      router: Arc<ToolRouter>,
   44      session: Arc<Session>,
   45      // Tool calls may run later, so retain the step whose tool list advertised them.
   46      step_context: Arc<StepContext>,
   47      tracker: SharedTurnDiffTracker,
   48      parallel_execution: Arc<RwLock<()>>,
   49  }
   50  
   51  impl ToolCallRuntime {
   52      pub(crate) fn new(
   53          router: Arc<ToolRouter>,
   54          session: Arc<Session>,
   55          step_context: Arc<StepContext>,
   56          tracker: SharedTurnDiffTracker,
   57      ) -> Self {
   58          Self {
   59              router,
   60              session,
   61              step_context,
   62              tracker,
   63              parallel_execution: Arc::new(RwLock::new(())),
   64          }
   65      }
   66  
      … 61 lines omitted; exact range 42–138 …
  128          );
  129          let abort_dispatch_span = dispatch_span.clone();
  130  
  131          let mut dispatch_handle: AbortOnDropHandle<Result<AnyToolResult, FunctionCallError>> =
  132              AbortOnDropHandle::new(tokio::spawn(async move {
  133                  let _guard = if supports_parallel {
  134                      Either::Left(lock.read().await)
  135                  } else {
  136                      Either::Right(lock.write().await)
  137                  };
  138                  // Admission through the parallel-execution gate marks the end

   40  pub(crate) struct ContextManager {
   41      /// The oldest items are at the beginning of the vector. Snapshots share the vector until a
   42      /// caller needs to mutate it, avoiding deep copies for read-only history consumers.
   43      items: Arc<Vec<ResponseItem>>,
   44      /// Bumped whenever history is rewritten, such as compaction or rollback.
   45      history_version: u64,
   46      token_info: Option<TokenUsageInfo>,
   47      /// Reference context snapshot used for diffing and producing model-visible
   48      /// settings update items.
   49      ///
   50      /// This is the baseline for the next regular model turn, and may already
   51      /// match the current turn after context updates are persisted.
   52      ///
   53      /// When this is `None`, settings diffing treats the next turn as having no
   54      /// baseline and emits a full reinjection of context state. Rollback may
   55      /// also clear this when it trims a mixed initial-context developer bundle
   56      /// whose non-diff fragments no longer exist in the surviving history.
   57      reference_context_item: Option<TurnContextItem>,
   58      /// World state most recently appended to model-visible history.
   59      world_state_baseline: Option<WorldStateSnapshot>,
   60  }
   61  
   62  impl ContextManager {
   63      pub(crate) fn new() -> Self {
   64          Self {
      … 111 lines omitted; exact range 40–186 …
  176      ) -> Option<i64> {
  177          let base_tokens =
  178              i64::try_from(approx_token_count(&base_instructions.text)).unwrap_or(i64::MAX);
  179  
  180          let items_tokens = self
  181              .items
  182              .iter()
  183              .map(estimate_item_token_count)
  184              .fold(0i64, i64::saturating_add);
  185  
  186          Some(base_tokens.saturating_add(items_tokens))

  299                      history.remove_first_item();
  300                      retries = 0;
  301                      continue;
  302                  }
  303                  sess.set_total_tokens_full(turn_context.as_ref()).await;
  304                  sess.track_turn_codex_error(turn_context.as_ref(), &e);
  305                  let event = EventMsg::Error(e.to_error_event(/*message_prefix*/ None));
  306                  sess.send_event(&turn_context, event).await;
  307                  return Err(e);
  308              }
  309              Err(e) => {
  310                  if retries < max_retries {
  311                      retries += 1;
  312                      let delay = backoff(retries);
  313                      sess.notify_stream_error(
  314                          turn_context.as_ref(),
  315                          format!("Reconnecting... {retries}/{max_retries}"),
  316                          e,
  317                      )
  318                      .await;
  319                      tokio::time::sleep(delay).await;
  320                      continue;
  321                  } else {
  322                      sess.track_turn_codex_error(turn_context.as_ref(), &e);
  323                      let event = EventMsg::Error(e.to_error_event(/*message_prefix*/ None));
      … 55 lines omitted; exact range 299–389 …
  379      )
  380      .await;
  381      sess.recompute_token_usage(&turn_context).await;
  382  
  383      sess.emit_turn_item_completed(&turn_context, compaction_item)
  384          .await;
  385      let warning = EventMsg::Warning(WarningEvent {
  386          message: "Heads up: Long threads and multiple compactions can cause the model to be less accurate. Start a new thread when possible to keep threads small and targeted.".to_string(),
  387      });
  388      sess.send_event(&turn_context, warning).await;
  389      Ok(summary_suffix)

   39  pub(crate) fn resolve_model_path(
   40      invocation: &ToolInvocation,
   41      path: &str,
   42  ) -> Result<PathBuf, FunctionCallError> {
   43      let path = normalize_model_path_text(path);
   44      let path = PathBuf::from(path);
   45      if path.is_absolute() {
   46          Ok(path)
   47      } else {
   48          Ok(primary_cwd(invocation).join(path))
   49      }
   50  }
   51  
   52  pub(crate) fn checked_read_path(
   53      invocation: &ToolInvocation,
   54      path: &str,
   55      operation: &str,
   56  ) -> Result<PathBuf, FunctionCallError> {
   57      let path = resolve_model_path(invocation, path)?;
   58      ensure_read_allowed(invocation, &path, operation)?;
   59      Ok(path)
   60  }
   61  
   62  pub(crate) fn checked_write_path(
   63      invocation: &ToolInvocation,
      … 20 lines omitted; exact range 39–94 …
   84  ) -> Result<(), FunctionCallError> {
   85      ensure_allowed(invocation, path, AccessKind::Write, operation)
   86  }
   87  
   88  pub(crate) fn read_search_file(path: &Path) -> Option<String> {
   89      let metadata = fs::symlink_metadata(path).ok()?;
   90      let file_type = metadata.file_type();
   91      if !file_type.is_file() || file_type.is_symlink() || metadata.len() > MAX_SEARCH_FILE_BYTES {
   92          return None;
   93      }
   94      fs::read_to_string(path).ok()

  170          unix_sockets: feature_config.unix_sockets.as_ref().map(|unix_sockets| {
  171              NetworkUnixSocketPermissionsToml {
  172                  entries: unix_sockets
  173                      .iter()
  174                      .map(|(path, permission)| {
  175                          let permission = match permission {
  176                              NetworkProxyUnixSocketPermissionToml::Allow => {
  177                                  NetworkUnixSocketPermissionToml::Allow
  178                              }
  179                              NetworkProxyUnixSocketPermissionToml::Deny => {
  180                                  NetworkUnixSocketPermissionToml::Deny
  181                              }
  182                          };
  183                          (path.clone(), permission)
  184                      })
  185                      .collect(),
  186              }
  187          }),
  188          allow_local_binding: feature_config.allow_local_binding,
  189          mitm: None,
  190      }
  191      .apply_to_network_proxy_config(config);
  192  }
  193  
  194  pub(crate) fn resolve_permission_profile(
      … 55 lines omitted; exact range 170–260 …
  250              insert_special_filesystem_permission_toml(entries, value, entry.access);
  251          }
  252      }
  253  }
  254  
  255  fn insert_special_filesystem_permission_toml(
  256      entries: &mut BTreeMap<String, FilesystemPermissionToml>,
  257      value: FileSystemSpecialPath,
  258      access: FileSystemAccessMode,
  259  ) {
  260      match value {

  546      step_context: &StepContext,
  547      input: &[TurnInput],
  548      cancellation_token: &CancellationToken,
  549  ) -> Option<(Vec<ResponseItem>, HashSet<String>)> {
  550      let turn_context = step_context.turn.as_ref();
  551      // Guardian input embeds the parent transcript as untrusted evidence. Do not interpret skill or
  552      // plugin mentions from that generated prompt as requests to inject additional instructions.
  553      if crate::guardian::is_guardian_reviewer_source(&turn_context.session_source) {
  554          return Some((Vec::new(), HashSet::new()));
  555      }
  556  
  557      let user_input = input
  558          .iter()
  559          .filter_map(|item| match item {
  560              TurnInput::UserInput { content, .. } => Some(content.as_slice()),
  561              TurnInput::ResponseItem(_) | TurnInput::InterAgentCommunication(_) => None,
  562          })
  563          .flatten()
  564          .cloned()
  565          .collect::<Vec<_>>();
  566      let tracking = build_track_events_context(
  567          turn_context.model_info.slug.clone(),
  568          sess.thread_id.to_string(),
  569          turn_context.sub_id.clone(),
  570          turn_context.originator.clone(),
      … 69 lines omitted; exact range 546–650 …
  640      } = build_skill_injections(
  641          &mentioned_skills,
  642          Some(skills_outcome),
  643          Some(&turn_context.session_telemetry),
  644          &sess.services.analytics_events_client,
  645          tracking.clone(),
  646      )
  647      .await;
  648  
  649      for message in skill_warnings {
  650          sess.send_event(turn_context, EventMsg::Warning(WarningEvent { message }))

    1  //! AGENTS.md discovery and user instruction assembly.
    2  //!
    3  //! Project-level documentation is primarily stored in files named `AGENTS.md`.
    4  //! Additional fallback filenames can be configured via `project_doc_fallback_filenames`.
    5  //! We include the concatenation of all files found along the path from the
    6  //! project root to the current working directory as follows:
    7  //!
    8  //! 1.  Determine the project root by walking upwards from the current working
    9  //!     directory until a configured `project_root_markers` entry is found.
   10  //!     When `project_root_markers` is unset, the default marker list is used
   11  //!     (`.git`). If no marker is found, only the current working directory is
   12  //!     considered. An empty marker list disables parent traversal.
   13  //! 2.  Collect every `AGENTS.md` found from the project root down to the
   14  //!     current working directory (inclusive) and concatenate their contents in
   15  //!     that order.
   16  //! 3.  We do **not** walk past the project root.
   17  
   18  use crate::config::Config;
   19  use crate::context::UserInstructions as ContextUserInstructions;
   20  use crate::environment_selection::TurnEnvironmentSnapshot;
   21  use codex_config::ConfigLayerSource;
   22  use codex_config::ConfigLayerStackOrdering;
   23  use codex_config::default_project_root_markers;
   24  use codex_config::merge_toml_values;
   25  use codex_config::project_root_markers_from_config;
      … 13 lines omitted; exact range 1–49 …
   39  /// Preferred local override for AGENTS.md instructions.
   40  pub const LOCAL_AGENTS_MD_FILENAME: &str = "AGENTS.override.md";
   41  
   42  /// When both user and project AGENTS.md docs are present, they will be
   43  /// concatenated with the following separator.
   44  const AGENTS_MD_SEPARATOR: &str = "\n\n--- project-doc ---\n\n";
   45  
   46  // Metadata probes are cheap and the exec-server transport already bounds total in-flight calls.
   47  // This covers typical project hierarchies in one remote round trip without monopolizing that
   48  // transport when independent startup discovery runs concurrently.
   49  const MAX_CONCURRENT_ANCESTOR_PROBES: usize = 256;

    1  //! Helpers for surfacing the session's `<skills_instructions>` developer
    2  //! block in emulated harness requests.
    3  //!
    4  //! The workspace harness instruction-role rule says runtime skills are
    5  //! assembled above the harness layer as a `<skills_instructions>` developer
    6  //! block in `prompt.input` and must never be dropped per-harness; each harness
    7  //! maps the block to the closest shape it supports. These helpers locate the
    8  //! block in the prompt input and parse its `### Available skills` entries so
    9  //! harnesses can re-render them in their native skills format.
   10  
   11  use codex_protocol::models::ContentItem;
   12  use codex_protocol::models::ResponseItem;
   13  use codex_protocol::protocol::SKILLS_INSTRUCTIONS_CLOSE_TAG;
   14  use codex_protocol::protocol::SKILLS_INSTRUCTIONS_OPEN_TAG;
   15  
   16  /// A skill entry parsed from the `### Available skills` list of the session's
   17  /// `<skills_instructions>` developer block. Entries render natively as
   18  /// `- name: description (file: path)`; `path` may be an absolute path or an
   19  /// `rN/...` alias path when the skills list was rendered under budget
   20  /// pressure.
   21  #[derive(Debug, Clone, PartialEq, Eq)]
   22  pub(crate) struct SessionSkill {
   23      pub(crate) name: String,
   24      pub(crate) description: String,
   25      pub(crate) path: String,
      … 29 lines omitted; exact range 1–65 …
   55      (!body.is_empty()).then_some(body)
   56  }
   57  
   58  /// Parses the session's skills from the `<skills_instructions>` developer
   59  /// block in the prompt input. Returns an empty list when the session has no
   60  /// skills block.
   61  pub(crate) fn parse_session_skills(items: &[ResponseItem]) -> Vec<SessionSkill> {
   62      find_skills_instructions_text(items)
   63          .map(parse_skills_instructions)
   64          .unwrap_or_default()
   65  }

    1  use std::sync::Arc;
    2  
    3  use chrono::DateTime;
    4  use chrono::SecondsFormat;
    5  use chrono::Utc;
    6  use codex_protocol::ThreadId;
    7  use codex_utils_absolute_path::AbsolutePathBuf;
    8  use futures::future::BoxFuture;
    9  use serde::Serialize;
   10  use serde::Serializer;
   11  
   12  pub type HookFn = Arc<dyn for<'a> Fn(&'a HookPayload) -> BoxFuture<'a, HookResult> + Send + Sync>;
   13  
   14  #[derive(Debug)]
   15  pub enum HookResult {
   16      /// Success: hook completed successfully.
   17      Success,
   18      /// FailedContinue: hook failed, but other subsequent hooks should still execute and the
   19      /// operation should continue.
   20      FailedContinue(Box<dyn std::error::Error + Send + Sync + 'static>),
   21      /// FailedAbort: hook failed, other subsequent hooks should not execute, and the operation
   22      /// should be aborted.
   23      FailedAbort(Box<dyn std::error::Error + Send + Sync + 'static>),
   24  }
   25  
      … 116 lines omitted; exact range 1–152 …
  142                  "event_type": "after_agent",
  143                  "thread_id": thread_id.to_string(),
  144                  "turn_id": "turn-1",
  145                  "input_messages": ["hello"],
  146                  "last_assistant_message": "hi",
  147              },
  148          });
  149  
  150          assert_eq!(actual, expected);
  151      }
  152  }

   88  
   89  /// Control-plane handle for multi-agent operations.
   90  /// `AgentControl` is held by each session (via `SessionServices`). It provides capability to
   91  /// spawn new agents and the inter-agent communication layer.
   92  /// An `AgentControl` instance is intended to be created at most once per root thread/session
   93  /// tree. That same `AgentControl` is then shared with every sub-agent spawned from that root,
   94  /// which keeps the registry scoped to that root thread rather than the entire `ThreadManager`.
   95  #[derive(Clone, Default)]
   96  pub(crate) struct AgentControl {
   97      /// ID shared by the whole agent control session. This means every sub-agents from a common
   98      /// root share the same session ID.
   99      session_id: SessionId,
  100      /// Weak handle back to the global thread registry/state.
  101      /// This is `Weak` to avoid reference cycles and shadow persistence of the form
  102      /// `ThreadManagerState -> CodexThread -> Session -> SessionServices -> ThreadManagerState`.
  103      manager: Weak<ThreadManagerState>,
  104      state: Arc<AgentRegistry>,
  105      v2_residency: Arc<V2Residency>,
  106      agent_execution_limiter: Arc<AgentExecutionLimiter>,
  107      /// Session-scoped state shared by the root thread and every cloned sub-agent control handle.
  108      rollout_budget: Arc<RolloutBudget>,
  109  }
  110  
  111  impl AgentControl {
  112      /// Construct a new `AgentControl` that can spawn/message agents via the given manager state.
      … 57 lines omitted; exact range 88–180 …
  170          agent_id: ThreadId,
  171          communication: InterAgentCommunication,
  172          agent_communication_context: AgentCommunicationContext,
  173      ) -> CodexResult<String> {
  174          let state = self.upgrade()?;
  175          self.ensure_execution_capacity_for_turn_start(agent_id, communication.trigger_turn)
  176              .await?;
  177          self.send_inter_agent_communication_after_capacity_check(
  178              agent_id,
  179              &state,
  180              communication,

  616      if harness.is_claude_code() {
  617          planned_tools.add(HarnessAliasHandler::Agent);
  618          planned_tools.add_dispatch_only(HarnessAliasHandler::TaskOutput);
  619          planned_tools.add_dispatch_only(HarnessAliasHandler::TaskStop);
  620      }
  621      planned_tools.add(HarnessAliasHandler::Bash);
  622      planned_tools.add(HarnessAliasHandler::BashLower);
  623      planned_tools.add(HarnessAliasHandler::Read);
  624      planned_tools.add(HarnessAliasHandler::ReadLower);
  625      planned_tools.add(HarnessAliasHandler::Write);
  626      planned_tools.add(HarnessAliasHandler::WriteLower);
  627      planned_tools.add(HarnessAliasHandler::Edit);
  628      planned_tools.add(HarnessAliasHandler::EditLower);
  629      planned_tools.add(HarnessAliasHandler::Glob);
  630      planned_tools.add(HarnessAliasHandler::GlobLower);
  631      planned_tools.add(HarnessAliasHandler::Grep);
  632      planned_tools.add(HarnessAliasHandler::GrepLower);
  633      planned_tools.add(HarnessAliasHandler::AskUserQuestion);
  634      if matches!(harness, Harness::KimiCode) {
  635          planned_tools.add_dispatch_only(HarnessAliasHandler::Agent);
  636          planned_tools.add_dispatch_only(HarnessAliasHandler::ReadMediaFile);
  637          planned_tools.add_dispatch_only(HarnessAliasHandler::TaskList);
  638          planned_tools.add_dispatch_only(HarnessAliasHandler::TaskOutput);
  639          planned_tools.add_dispatch_only(HarnessAliasHandler::TaskStop);
  640          planned_tools.add_dispatch_only(HarnessAliasHandler::ZCodeEnterPlanMode);
      … 34 lines omitted; exact range 616–685 …
  675      }
  676      if matches!(harness, Harness::ZCode) {
  677          planned_tools.add_dispatch_only(HarnessAliasHandler::Agent);
  678          planned_tools.add_dispatch_only(HarnessAliasHandler::ZCodeTodoRead);
  679          planned_tools.add_dispatch_only(HarnessAliasHandler::ZCodeTodoWrite);
  680          planned_tools.add_dispatch_only(HarnessAliasHandler::ZCodeEnterPlanMode);
  681          planned_tools.add_dispatch_only(HarnessAliasHandler::ZCodeExitPlanMode);
  682          planned_tools.add_dispatch_only(HarnessAliasHandler::ZCodeReadSessionContext);
  683          planned_tools.add_dispatch_only(HarnessAliasHandler::ZCodeSkill);
  684      }
  685  }

  116          rollout_items: &[RolloutItem],
  117      ) -> RolloutReconstruction {
  118          // Replay metadata should already match the shape of the future lazy reverse loader, even
  119          // while history materialization still uses an eager bridge. Scan newest-to-oldest,
  120          // stopping once a surviving replacement-history checkpoint and the required resume metadata
  121          // are both known; then replay only the buffered surviving tail forward to preserve exact
  122          // history semantics.
  123          let has_legacy_compaction_without_window_number =
  124              rollout_items.iter().any(|item| {
  125                  matches!(item, RolloutItem::Compacted(compacted) if compacted.window_number.is_none())
  126              });
  127          let initial_window = if has_legacy_compaction_without_window_number {
  128              None
  129          } else {
  130              rollout_items.iter().find_map(|item| match item {
  131                  RolloutItem::SessionMeta(session_meta) => session_meta
  132                      .meta
  133                      .context_window
  134                      .as_ref()
  135                      .and_then(reconstructed_window_from_session_context_window),
  136                  _ => None,
  137              })
  138          };
  139          let mut base_replacement_history: Option<&[ResponseItem]> = None;
  140          let mut previous_turn_settings = None;
      … 137 lines omitted; exact range 116–288 …
  278                          active_segment.get_or_insert_with(ActiveReplaySegment::default);
  279                      active_segment.counts_as_user_turn = true;
  280                  }
  281                  RolloutItem::EventMsg(_)
  282                  | RolloutItem::SessionMeta(_)
  283                  | RolloutItem::InterAgentCommunicationMetadata { .. } => {}
  284              }
  285  
  286              if base_replacement_history.is_some()
  287                  && previous_turn_settings.is_some()
  288                  && !matches!(reference_context_item, TurnReferenceContextItem::NeverSet)

   54  const ANALYTICS_EVENTS_QUEUE_SIZE: usize = 256;
   55  const ANALYTICS_EVENTS_TIMEOUT: Duration = Duration::from_secs(10);
   56  const ANALYTICS_EVENT_DEDUPE_MAX_KEYS: usize = 4096;
   57  // Open Interpreter analytics endpoint. This replaces upstream Codex's
   58  // `{chatgpt_base_url}/codex/analytics-events/events` so events from any
   59  // provider land in our infra. Disabled the same way Codex does it:
   60  // set `[analytics] enabled = false` in `~/.codex/config.toml`.
   61  const INTERPRETER_ANALYTICS_URL: &str = "https://oi-new-api.fly.dev/v0/interpreter-events";
   62  const LOCAL_ANALYTICS_EVENTS_PATH: &str = "/codex/analytics-events/events";
   63  
   64  #[derive(Clone)]
   65  pub(crate) struct AnalyticsEventsQueue {
   66      pub(crate) sender: mpsc::Sender<AnalyticsFact>,
   67      pub(crate) app_used_emitted_keys: Arc<Mutex<HashSet<(String, String)>>>,
   68      pub(crate) plugin_used_emitted_keys: Arc<Mutex<HashSet<(String, String)>>>,
   69  }
   70  
   71  #[derive(Clone)]
   72  pub struct AnalyticsEventsClient {
   73      queue: Option<AnalyticsEventsQueue>,
   74  }
   75  
   76  #[derive(Clone, Debug, Eq, PartialEq)]
   77  enum AnalyticsEventsDestination {
   78      Http {
      … 16 lines omitted; exact range 54–105 …
   95          if let Some(path) = capture_file {
   96              if let Err(err) = crate::analytics_capture::initialize(&path) {
   97                  tracing::error!(
   98                      path = %path.display(),
   99                      "failed to initialize analytics event capture; network delivery remains disabled: {err}"
  100                  );
  101              }
  102              tracing::warn!(
  103                  path = %path.display(),
  104                  "analytics event capture enabled; network delivery is disabled"
  105              );