What Are App Dependencies in OpenAI Plugins? A Complete Technical Guide

App dependencies are the third-party libraries and runtime packages declared in a plugin's manifest file (such as .app.json or pyproject.toml) that an OpenAI Agents SDK app requires to compile, run, and interact with the OpenAI platform.

In the openai/plugins repository, app dependencies define the external code required by the executable component of a plugin. These dependencies are version-controlled within manifest files, ensuring reproducible builds and transparent dependency trees for anyone auditing the source code.

Declaring App Dependencies in the Manifest

OpenAI plugins declare app dependencies within structured manifest files that the build system parses during packaging. The specific file format depends on the runtime environment of the app.

Node.js Apps (.app.json)

For JavaScript-based plugins, dependencies are enumerated in a .app.json manifest file located in the plugin root. According to the plugins/outlook-calendar/.app.json example, this JSON structure lists required npm packages under a dependencies object.

{
  "name": "outlook-calendar-app",
  "version": "0.1.0",
  "main": "src/main.js",
  "dependencies": {
    "openai-agents": "^0.7.0",
    "express": "^4.18.2",
    "dotenv": "^16.0.3"
  }
}

The manifest specifies exact or semantic versions (e.g., ^0.7.0), ensuring the build system installs compatible package combinations.

Python Apps (pyproject.toml)

Python-based plugins declare app dependencies within pyproject.toml using optional dependency groups. As implemented in the repository's Python plugin examples, the [project.optional-dependencies] section often contains an app group isolating runtime requirements.

[project]
name = "my-openai-plugin"
requires-python = ">=3.10"

[project.optional-dependencies]
app = [
    "openai-agents>=0.7.0",
    "fastapi>=0.109.0",
    "uvicorn[standard]>=0.23.2"
]

This structure separates core package dependencies from those specifically required for the app's execution environment.

The Installation Workflow

The build system processes app dependencies through a standardized pipeline that ensures all external code is present before the app initializes.

1. Inspect the manifest – The build system reads .app.json or pyproject.toml to identify required packages listed under dependencies or devDependencies fields.

2. Install dependencies – The appropriate package manager executes installation commands. For Node.js apps, this means running npm install or yarn install. For Python apps, the system runs uv pip install -r requirements.txt or uv add openai-agents when using pyproject.toml directly.

3. Run the app – Once dependencies are resolved, the app starts via commands like uv run python main.py or node src/main.js, exposing the plugin's API endpoints with all required libraries loaded.

Core Dependencies for OpenAI Plugins

While app dependencies vary by plugin functionality, certain libraries are ubiquitous across the ecosystem.

The openai-agents SDK represents the most critical dependency for OpenAI-powered apps. According to plugins/openai-developers/skills/agents-sdk/SKILL.md at line 127, the documentation explicitly states that apps must list openai-agents in the app dependencies to access core Agent, Tool, and Sandbox abstractions.

Additional common dependencies include:

• FastAPI or Express – Framework libraries for API endpoint implementation
• axios or requests – HTTP client libraries for external service communication
• lodash or pydantic – Utility packages for data validation and manipulation

Because these declarations reside in version-controlled manifest files within the openai/plugins repository, the dependency list remains visible and auditable, ensuring transparency regarding what external code the plugin executes.

Summary

• App dependencies are third-party libraries declared in .app.json or pyproject.toml that an OpenAI plugin requires to function.
• The openai-agents package is the primary dependency required for Agents SDK implementations, as documented in plugins/openai-developers/skills/agents-sdk/SKILL.md.
• Installation occurs through standard package managers (npm, uv, pip, yarn) during the build process before the app initializes.
• Manifest files are version-controlled within the plugin repository, ensuring reproducible builds and dependency transparency.

Frequently Asked Questions

What file declares app dependencies in an OpenAI plugin?

App dependencies are declared in the app's manifest file, typically .app.json for Node.js applications or pyproject.toml for Python applications. These files reside in the plugin root directory and are parsed by the build system during the packaging process.

Is the openai-agents package required for all OpenAI plugins?

While not universal, openai-agents is required for any plugin implementing the Agents SDK pattern. According to plugins/openai-developers/skills/agents-sdk/SKILL.md, the SDK must be listed in the app dependencies to provide the Agent, Tool, and Sandbox abstractions necessary for OpenAI platform interaction.

How are app dependencies installed during the build process?

The build system reads the manifest file and invokes the appropriate package manager. For Node.js apps, this executes npm install or yarn install using the dependencies object in .app.json. For Python apps, the system runs uv pip install or pip install against the requirements listed in pyproject.toml or requirements.txt.

Are app dependencies visible to plugin users?

Yes. Because manifest files like .app.json and pyproject.toml are committed to the plugin repository (as seen in plugins/outlook-calendar/.app.json), the complete dependency tree is version-controlled and publicly visible. This transparency allows users to audit exactly which external libraries the plugin will execute before installation.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}