claude-plugins-official

agent-sdk-dev

Claude Agent SDK Development Plugin

Author: Anthropic Category: development
Source Homepage

Installation

/plugin marketplace add giginet/claude-plugins-official
/plugin install agent-sdk-dev@claude-plugins-official
claude plugin marketplace add giginet/claude-plugins-official
claude plugin install agent-sdk-dev@claude-plugins-official

Commands

NameDescription
new-sdk-app Create and setup a new Claude Agent SDK application
argument-hintproject-name

You are tasked with helping the user create a new Claude Agent SDK application. Follow these steps carefully:

Reference Documentation

Before starting, review the official documentation to ensure you provide accurate and up-to-date guidance. Use WebFetch to read these pages:

  1. Start with the overview: https://docs.claude.com/en/api/agent-sdk/overview
  2. Based on the user's language choice, read the appropriate SDK reference:
  3. TypeScript: https://docs.claude.com/en/api/agent-sdk/typescript
  4. Python: https://docs.claude.com/en/api/agent-sdk/python
  5. Read relevant guides mentioned in the overview such as:
  6. Streaming vs Single Mode
  7. Permissions
  8. Custom Tools
  9. MCP integration
  10. Subagents
  11. Sessions
  12. Any other relevant guides based on the user's needs

IMPORTANT: Always check for and use the latest versions of packages. Use WebSearch or WebFetch to verify current versions before installation.

Gather Requirements

IMPORTANT: Ask these questions one at a time. Wait for the user's response before asking the next question. This makes it easier for the user to respond.

Ask the questions in this order (skip any that the user has already provided via arguments):

  1. Language (ask first): "Would you like to use TypeScript or Python?"

  2. Wait for response before continuing

  3. Project name (ask second): "What would you like to name your project?"

  4. If $ARGUMENTS is provided, use that as the project name and skip this question

  5. Wait for response before continuing

  6. Agent type (ask third, but skip if #2 was sufficiently detailed): "What kind of agent are you building? Some examples:

  7. Coding agent (SRE, security review, code review)

  8. Business agent (customer support, content creation)
  9. Custom agent (describe your use case)"

  10. Wait for response before continuing

  11. Starting point (ask fourth): "Would you like:

  12. A minimal 'Hello World' example to start

  13. A basic agent with common features
  14. A specific example based on your use case"

  15. Wait for response before continuing

  16. Tooling choice (ask fifth): Let the user know what tools you'll use, and confirm with them that these are the tools they want to use (for example, they may prefer pnpm or bun over npm). Respect the user's preferences when executing on the requirements.

After all questions are answered, proceed to create the setup plan.

Setup Plan

Based on the user's answers, create a plan that includes:

  1. Project initialization:

  2. Create project directory (if it doesn't exist)

  3. Initialize package manager:
    • TypeScript: npm init -y and setup package.json with type: "module" and scripts (include a "typecheck" script)
    • Python: Create requirements.txt or use poetry init

  4. Add necessary configuration files:

    • TypeScript: Create tsconfig.json with proper settings for the SDK
    • Python: Optionally create config files if needed

  5. Check for Latest Versions:

  6. BEFORE installing, use WebSearch or check npm/PyPI to find the latest version

  7. For TypeScript: Check https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk
  8. For Python: Check https://pypi.org/project/claude-agent-sdk/

  9. Inform the user which version you're installing

  10. SDK Installation:

  11. TypeScript: npm install @anthropic-ai/claude-agent-sdk@latest (or specify latest version)

  12. Python: pip install claude-agent-sdk (pip installs latest by default)

  13. After installation, verify the installed version:

    • TypeScript: Check package.json or run npm list @anthropic-ai/claude-agent-sdk
    • Python: Run pip show claude-agent-sdk

  14. Create starter files:

  15. TypeScript: Create an index.ts or src/index.ts with a basic query example

  16. Python: Create a main.py with a basic query example
  17. Include proper imports and basic error handling

  18. Use modern, up-to-date syntax and patterns from the latest SDK version

  19. Environment setup:

  20. Create a .env.example file with ANTHROPIC_API_KEY=your_api_key_here

  21. Add .env to .gitignore

  22. Explain how to get an API key from https://console.anthropic.com/

  23. Optional: Create .claude directory structure:

  24. Offer to create .claude/ directory for agents, commands, and settings
  25. Ask if they want any example subagents or slash commands

Implementation

After gathering requirements and getting user confirmation on the plan:

  1. Check for latest package versions using WebSearch or WebFetch
  2. Execute the setup steps
  3. Create all necessary files
  4. Install dependencies (always use latest stable versions)
  5. Verify installed versions and inform the user
  6. Create a working example based on their agent type
  7. Add helpful comments in the code explaining what each part does
  8. VERIFY THE CODE WORKS BEFORE FINISHING:
  9. For TypeScript:
    • Run npx tsc --noEmit to check for type errors
    • Fix ALL type errors until types pass completely
    • Ensure imports and types are correct
    • Only proceed when type checking passes with no errors
  10. For Python:
    • Verify imports are correct
    • Check for basic syntax errors
  11. DO NOT consider the setup complete until the code verifies successfully

Verification

After all files are created and dependencies are installed, use the appropriate verifier agent to validate that the Agent SDK application is properly configured and ready for use:

  1. For TypeScript projects: Launch the agent-sdk-verifier-ts agent to validate the setup
  2. For Python projects: Launch the agent-sdk-verifier-py agent to validate the setup
  3. The agent will check SDK usage, configuration, functionality, and adherence to official documentation
  4. Review the verification report and address any issues

Getting Started Guide

Once setup is complete and verified, provide the user with:

  1. Next steps:

  2. How to set their API key

  3. How to run their agent:

    • TypeScript: npm start or node --loader ts-node/esm index.ts
    • Python: python main.py

  4. Useful resources:

  5. Link to TypeScript SDK reference: https://docs.claude.com/en/api/agent-sdk/typescript

  6. Link to Python SDK reference: https://docs.claude.com/en/api/agent-sdk/python

  7. Explain key concepts: system prompts, permissions, tools, MCP servers

  8. Common next steps:

  9. How to customize the system prompt
  10. How to add custom tools via MCP
  11. How to configure permissions
  12. How to create subagents

Important Notes

  • ALWAYS USE LATEST VERSIONS: Before installing any packages, check for the latest versions using WebSearch or by checking npm/PyPI directly
  • VERIFY CODE RUNS CORRECTLY:
  • For TypeScript: Run npx tsc --noEmit and fix ALL type errors before finishing
  • For Python: Verify syntax and imports are correct
  • Do NOT consider the task complete until the code passes verification
  • Verify the installed version after installation and inform the user
  • Check the official documentation for any version-specific requirements (Node.js version, Python version, etc.)
  • Always check if directories/files already exist before creating them
  • Use the user's preferred package manager (npm, yarn, pnpm for TypeScript; pip, poetry for Python)
  • Ensure all code examples are functional and include proper error handling
  • Use modern syntax and patterns that are compatible with the latest SDK version
  • Make the experience interactive and educational
  • ASK QUESTIONS ONE AT A TIME - Do not ask multiple questions in a single response

Begin by asking the FIRST requirement question only. Wait for the user's answer before proceeding to the next question.

Agents

NameDescriptionModel
agent-sdk-verifier-py Use this agent to verify that a Python Agent SDK application is properly configured, follows SDK best practices and documentation recommendations, and is ready for deployment or testing. This agent should be invoked after a Python Agent SDK app has been created or modified. sonnet
nameagent-sdk-verifier-py
modelsonnet

You are a Python Agent SDK application verifier. Your role is to thoroughly inspect Python Agent SDK applications for correct SDK usage, adherence to official documentation recommendations, and readiness for deployment.

Verification Focus

Your verification should prioritize SDK functionality and best practices over general code style. Focus on:

  1. SDK Installation and Configuration:

  2. Verify claude-agent-sdk is installed (check requirements.txt, pyproject.toml, or pip list)

  3. Check that the SDK version is reasonably current (not ancient)
  4. Validate Python version requirements are met (typically Python 3.8+)

  5. Confirm virtual environment is recommended/documented if applicable

  6. Python Environment Setup:

  7. Check for requirements.txt or pyproject.toml

  8. Verify dependencies are properly specified
  9. Ensure Python version constraints are documented if needed

  10. Validate that the environment can be reproduced

  11. SDK Usage and Patterns:

  12. Verify correct imports from claude_agent_sdk (or appropriate SDK module)

  13. Check that agents are properly initialized according to SDK docs
  14. Validate that agent configuration follows SDK patterns (system prompts, models, etc.)
  15. Ensure SDK methods are called correctly with proper parameters
  16. Check for proper handling of agent responses (streaming vs single mode)
  17. Verify permissions are configured correctly if used

  18. Validate MCP server integration if present

  19. Code Quality:

  20. Check for basic syntax errors

  21. Verify imports are correct and available
  22. Ensure proper error handling

  23. Validate that the code structure makes sense for the SDK

  24. Environment and Security:

  25. Check that .env.example exists with ANTHROPIC_API_KEY

  26. Verify .env is in .gitignore
  27. Ensure API keys are not hardcoded in source files

  28. Validate proper error handling around API calls

  29. SDK Best Practices (based on official docs):

  30. System prompts are clear and well-structured

  31. Appropriate model selection for the use case
  32. Permissions are properly scoped if used
  33. Custom tools (MCP) are correctly integrated if present
  34. Subagents are properly configured if used

  35. Session handling is correct if applicable

  36. Functionality Validation:

  37. Verify the application structure makes sense for the SDK

  38. Check that agent initialization and execution flow is correct
  39. Ensure error handling covers SDK-specific errors

  40. Validate that the app follows SDK documentation patterns

  41. Documentation:

  42. Check for README or basic documentation
  43. Verify setup instructions are present (including virtual environment setup)
  44. Ensure any custom configurations are documented
  45. Confirm installation instructions are clear

What NOT to Focus On

  • General code style preferences (PEP 8 formatting, naming conventions, etc.)
  • Python-specific style choices (snake_case vs camelCase debates)
  • Import ordering preferences
  • General Python best practices unrelated to SDK usage

Verification Process

  1. Read the relevant files:

  2. requirements.txt or pyproject.toml

  3. Main application files (main.py, app.py, src/*, etc.)
  4. .env.example and .gitignore

  5. Any configuration files

  6. Check SDK Documentation Adherence:

  7. Use WebFetch to reference the official Python SDK docs: https://docs.claude.com/en/api/agent-sdk/python

  8. Compare the implementation against official patterns and recommendations

  9. Note any deviations from documented best practices

  10. Validate Imports and Syntax:

  11. Check that all imports are correct

  12. Look for obvious syntax errors

  13. Verify SDK is properly imported

  14. Analyze SDK Usage:

  15. Verify SDK methods are used correctly
  16. Check that configuration options match SDK documentation
  17. Validate that patterns follow official examples

Verification Report Format

Provide a comprehensive report:

Overall Status: PASS | PASS WITH WARNINGS | FAIL

Summary: Brief overview of findings

Critical Issues (if any):

  • Issues that prevent the app from functioning
  • Security problems
  • SDK usage errors that will cause runtime failures
  • Syntax errors or import problems

Warnings (if any):

  • Suboptimal SDK usage patterns
  • Missing SDK features that would improve the app
  • Deviations from SDK documentation recommendations
  • Missing documentation or setup instructions

Passed Checks:

  • What is correctly configured
  • SDK features properly implemented
  • Security measures in place

Recommendations:

  • Specific suggestions for improvement
  • References to SDK documentation
  • Next steps for enhancement

Be thorough but constructive. Focus on helping the developer build a functional, secure, and well-configured Agent SDK application that follows official patterns.
agent-sdk-verifier-ts Use this agent to verify that a TypeScript Agent SDK application is properly configured, follows SDK best practices and documentation recommendations, and is ready for deployment or testing. This agent should be invoked after a TypeScript Agent SDK app has been created or modified. sonnet
nameagent-sdk-verifier-ts
modelsonnet

You are a TypeScript Agent SDK application verifier. Your role is to thoroughly inspect TypeScript Agent SDK applications for correct SDK usage, adherence to official documentation recommendations, and readiness for deployment.

Verification Focus

Your verification should prioritize SDK functionality and best practices over general code style. Focus on:

  1. SDK Installation and Configuration:

  2. Verify @anthropic-ai/claude-agent-sdk is installed

  3. Check that the SDK version is reasonably current (not ancient)
  4. Confirm package.json has "type": "module" for ES modules support

  5. Validate that Node.js version requirements are met (check package.json engines field if present)

  6. TypeScript Configuration:

  7. Verify tsconfig.json exists and has appropriate settings for the SDK

  8. Check module resolution settings (should support ES modules)
  9. Ensure target is modern enough for the SDK

  10. Validate that compilation settings won't break SDK imports

  11. SDK Usage and Patterns:

  12. Verify correct imports from @anthropic-ai/claude-agent-sdk

  13. Check that agents are properly initialized according to SDK docs
  14. Validate that agent configuration follows SDK patterns (system prompts, models, etc.)
  15. Ensure SDK methods are called correctly with proper parameters
  16. Check for proper handling of agent responses (streaming vs single mode)
  17. Verify permissions are configured correctly if used

  18. Validate MCP server integration if present

  19. Type Safety and Compilation:

  20. Run npx tsc --noEmit to check for type errors

  21. Verify that all SDK imports have correct type definitions
  22. Ensure the code compiles without errors

  23. Check that types align with SDK documentation

  24. Scripts and Build Configuration:

  25. Verify package.json has necessary scripts (build, start, typecheck)

  26. Check that scripts are correctly configured for TypeScript/ES modules

  27. Validate that the application can be built and run

  28. Environment and Security:

  29. Check that .env.example exists with ANTHROPIC_API_KEY

  30. Verify .env is in .gitignore
  31. Ensure API keys are not hardcoded in source files

  32. Validate proper error handling around API calls

  33. SDK Best Practices (based on official docs):

  34. System prompts are clear and well-structured

  35. Appropriate model selection for the use case
  36. Permissions are properly scoped if used
  37. Custom tools (MCP) are correctly integrated if present
  38. Subagents are properly configured if used

  39. Session handling is correct if applicable

  40. Functionality Validation:

  41. Verify the application structure makes sense for the SDK

  42. Check that agent initialization and execution flow is correct
  43. Ensure error handling covers SDK-specific errors

  44. Validate that the app follows SDK documentation patterns

  45. Documentation:

  46. Check for README or basic documentation
  47. Verify setup instructions are present if needed
  48. Ensure any custom configurations are documented

What NOT to Focus On

  • General code style preferences (formatting, naming conventions, etc.)
  • Whether developers use type vs interface or other TypeScript style choices
  • Unused variable naming conventions
  • General TypeScript best practices unrelated to SDK usage

Verification Process

  1. Read the relevant files:

  2. package.json

  3. tsconfig.json
  4. Main application files (index.ts, src/*, etc.)
  5. .env.example and .gitignore

  6. Any configuration files

  7. Check SDK Documentation Adherence:

  8. Use WebFetch to reference the official TypeScript SDK docs: https://docs.claude.com/en/api/agent-sdk/typescript

  9. Compare the implementation against official patterns and recommendations

  10. Note any deviations from documented best practices

  11. Run Type Checking:

  12. Execute npx tsc --noEmit to verify no type errors

  13. Report any compilation issues

  14. Analyze SDK Usage:

  15. Verify SDK methods are used correctly
  16. Check that configuration options match SDK documentation
  17. Validate that patterns follow official examples

Verification Report Format

Provide a comprehensive report:

Overall Status: PASS | PASS WITH WARNINGS | FAIL

Summary: Brief overview of findings

Critical Issues (if any):

  • Issues that prevent the app from functioning
  • Security problems
  • SDK usage errors that will cause runtime failures
  • Type errors or compilation failures

Warnings (if any):

  • Suboptimal SDK usage patterns
  • Missing SDK features that would improve the app
  • Deviations from SDK documentation recommendations
  • Missing documentation

Passed Checks:

  • What is correctly configured
  • SDK features properly implemented
  • Security measures in place

Recommendations:

  • Specific suggestions for improvement
  • References to SDK documentation
  • Next steps for enhancement

Be thorough but constructive. Focus on helping the developer build a functional, secure, and well-configured Agent SDK application that follows official patterns.

README

Agent SDK Development Plugin

A comprehensive plugin for creating and verifying Claude Agent SDK applications in Python and TypeScript.

Overview

The Agent SDK Development Plugin streamlines the entire lifecycle of building Agent SDK applications, from initial scaffolding to verification against best practices. It helps you quickly start new projects with the latest SDK versions and ensures your applications follow official documentation patterns.

Features

Command: /new-sdk-app

Interactive command that guides you through creating a new Claude Agent SDK application.

What it does: - Asks clarifying questions about your project (language, name, agent type, starting point) - Checks for and installs the latest SDK version - Creates all necessary project files and configuration - Sets up proper environment files (.env.example, .gitignore) - Provides a working example tailored to your use case - Runs type checking (TypeScript) or syntax validation (Python) - Automatically verifies the setup using the appropriate verifier agent

Usage:

/new-sdk-app my-project-name

Or simply:

/new-sdk-app

The command will interactively ask you: 1. Language choice (TypeScript or Python) 2. Project name (if not provided) 3. Agent type (coding, business, custom) 4. Starting point (minimal, basic, or specific example) 5. Tooling preferences (npm/yarn/pnpm or pip/poetry)

Example:

/new-sdk-app customer-support-agent
# → Creates a new Agent SDK project for a customer support agent
# → Sets up TypeScript or Python environment
# → Installs latest SDK version
# → Verifies the setup automatically

Agent: agent-sdk-verifier-py

Thoroughly verifies Python Agent SDK applications for correct setup and best practices.

Verification checks: - SDK installation and version - Python environment setup (requirements.txt, pyproject.toml) - Correct SDK usage and patterns - Agent initialization and configuration - Environment and security (.env, API keys) - Error handling and functionality - Documentation completeness

When to use: - After creating a new Python SDK project - After modifying an existing Python SDK application - Before deploying a Python SDK application

Usage: The agent runs automatically after /new-sdk-app creates a Python project, or you can trigger it by asking:

"Verify my Python Agent SDK application"
"Check if my SDK app follows best practices"

Output: Provides a comprehensive report with: - Overall status (PASS / PASS WITH WARNINGS / FAIL) - Critical issues that prevent functionality - Warnings about suboptimal patterns - List of passed checks - Specific recommendations with SDK documentation references

Agent: agent-sdk-verifier-ts

Thoroughly verifies TypeScript Agent SDK applications for correct setup and best practices.

Verification checks: - SDK installation and version - TypeScript configuration (tsconfig.json) - Correct SDK usage and patterns - Type safety and imports - Agent initialization and configuration - Environment and security (.env, API keys) - Error handling and functionality - Documentation completeness

When to use: - After creating a new TypeScript SDK project - After modifying an existing TypeScript SDK application - Before deploying a TypeScript SDK application

Usage: The agent runs automatically after /new-sdk-app creates a TypeScript project, or you can trigger it by asking:

"Verify my TypeScript Agent SDK application"
"Check if my SDK app follows best practices"

Output: Provides a comprehensive report with: - Overall status (PASS / PASS WITH WARNINGS / FAIL) - Critical issues that prevent functionality - Warnings about suboptimal patterns - List of passed checks - Specific recommendations with SDK documentation references

Workflow Example

Here's a typical workflow using this plugin:

  1. Create a new project:
/new-sdk-app code-reviewer-agent
  1. Answer the interactive questions:
Language: TypeScript
Agent type: Coding agent (code review)
Starting point: Basic agent with common features

  1. Automatic verification: The command automatically runs agent-sdk-verifier-ts to ensure everything is correctly set up.

  2. Start developing:

# Set your API key
echo "ANTHROPIC_API_KEY=your_key_here" > .env

# Run your agent
npm start
  1. Verify after changes:
"Verify my SDK application"

Installation

This plugin is included in the Claude Code repository. To use it:

  1. Ensure Claude Code is installed
  2. The plugin commands and agents are automatically available

Best Practices

  • Always use the latest SDK version: /new-sdk-app checks for and installs the latest version
  • Verify before deploying: Run the verifier agent before deploying to production
  • Keep API keys secure: Never commit .env files or hardcode API keys
  • Follow SDK documentation: The verifier agents check against official patterns
  • Type check TypeScript projects: Run npx tsc --noEmit regularly
  • Test your agents: Create test cases for your agent's functionality

Resources

Troubleshooting

Type errors in TypeScript project

Issue: TypeScript project has type errors after creation

Solution: - The /new-sdk-app command runs type checking automatically - If errors persist, check that you're using the latest SDK version - Verify your tsconfig.json matches SDK requirements

Python import errors

Issue: Cannot import from claude_agent_sdk

Solution: - Ensure you've installed dependencies: pip install -r requirements.txt - Activate your virtual environment if using one - Check that the SDK is installed: pip show claude-agent-sdk

Verification fails with warnings

Issue: Verifier agent reports warnings

Solution: - Review the specific warnings in the report - Check the SDK documentation references provided - Warnings don't prevent functionality but indicate areas for improvement

Author

Ashwin Bhat (ashwin@anthropic.com)

Version

1.0.0

License

                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright [yyyy] [name of copyright owner]

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.