google-agents-cli-workflow
由 google 提供的 google-agents-cli-workflow Skill,包含安装方法、功能说明、完整指令和 GitHub 原文入口。
name: google-agents-cli-workflow description: > This skill should be used when the user wants to "develop an agent", "build an agent using ADK", "run the agent locally", "debug agent code", "test an agent", "deploy an agent", "publish an agent", "monitor an agent", or needs the ADK (Agent Development Kit) development lifecycle and coding guidelines. Entrypoint for building ADK agents. Always active — provides the full workflow (scaffold, build, evaluate, deploy, publish, observe), code preservation rules, model selection guidance, and troubleshooting steps for ADK or any agent development. metadata: author: Google license: Apache-2.0 version: 1.14.0 requires: bins: - agents-cli install: "uv tool install google-agents-cli"
功能说明
This skill should be used when the user wants to "develop an agent", "build an agent using ADK", "run the agent locally", "debug agent code", "test an agent", "deploy an agent", "publish an agent", "monitor an agent", or needs the ADK (Agent Development Kit) development lifecycle and coding guidelines. Entrypoint for building ADK agents. Always active — provides the full workflow (scaffold, build, evaluate, deploy, publish, observe), code preservation rules, model selection guidance, and troubleshooting steps for ADK or any agent development.
快速安装
npx skills add https://github.com/google/agents-cli --skill google-agents-cli-workflow
交给 AI 助手使用
以下是页面提示词的中文转述,命令保持原样。
运行 npx skills use "https://github.com/google/agents-cli" --skill "google-agents-cli-workflow",完整阅读输出并按 Skill 说明操作。必要时先将输出保存到临时文件;相对路径以输出提供的支持文件目录为准。
补充说明
This skill should be used when the user wants to "develop an agent", "build an agent using ADK", "run the agent locally", "debug agent code", "test an agent",...
Agent Development Workflow & Guidelines
agents-cli is a CLI and skills toolkit for building, evaluating, and deploying agents on Google Cloud. It works with any coding agent — Antigravity CLI, Claude Code, Codex, or others — and with the agent framework of your choice (the Agent Development Kit (ADK) by default). Install with uvx google-agents-cli setup.
Before writing agent code, make sure a scaffolded project exists (see Phase 2). Skipping scaffolding loses eval boilerplate, CI/CD config, and project conventions.
Requires: google-agents-cli
= 1.14.0 If version is behind, run: uv tool install "google-agents-cli=1.14.0"
Check version: agents-cli info Install uv first if needed.
Session Continuity & Skill Cross-References
Re-read the relevant skill before each phase — not after you've already started and hit a problem. Context compaction may have dropped earlier skill content. If skills are not available, run uvx google-agents-cli setup to install them.
| Phase | Skill | When to load |
|---|---|---|
| 0 — Understand | — | No skill needed — read .agents-cli-spec.md if present, else clarify goals with the user |
| 1 — Study recipes | /google-agents-cli-adk-code |
Load it during design, before scaffolding. Python: the references/recipes.md topic index maps a need to the recipe that implements it. Go: the upstream examples/ are the equivalent. Yes, load this early. |
| 2 — Scaffold | /google-agents-cli-scaffold |
Before creating or enhancing a project |
| 3 — Build | /google-agents-cli-adk-code |
Before writing agent code — API patterns, tools, callbacks, state |
| 4 — Evaluate | /google-agents-cli-eval |
Before running any eval — dataset schema, metrics, eval-fix loop |
| 5 — Deploy | /google-agents-cli-deploy |
Before deploying — target selection, troubleshooting 403/timeouts |
| 6 — Publish | /google-agents-cli-publish |
After deploying, if registering with Gemini (optional) |
| 7 — Observe | /google-agents-cli-observability |
After deploying — traces, logging, monitoring setup |
Setup
If agents-cli is not installed:
uv tool install google-agents-cli
uv command not found
Install uv following the official installation guide.
Product name mapping
Users name products inconsistently (Vertex AI or Agent Platform → Gemini platform, Agent Engine or Agent Runtime → Agent Runtime in Gemini platform, etc.). Map user terms to CLI values using references/terminology.md.
Phase 0: Understand
Before writing or scaffolding anything, understand what you're building — through a design dialogue, not a checklist. Load references/brainstorming.md and follow it: ask one question at a time, propose 2–3 architecture approaches for non-trivial agents, and validate the design before any scaffolding.
If .agents-cli-spec.md exists in the current directory, read it — it is your primary source of truth. Otherwise:
Do NOT proceed to planning, scaffolding, or coding until the user approves the spec. Do not assume, research, or fill in the blanks yourself — the user's intent drives everything.
Scale the ceremony to complexity: a trivial agent (single tool, fixed persona) needs only a couple of questions, a 2–3 sentence spec, and one approval; a complex agent (multi-agent, RAG, external APIs/auth, safety-critical) gets the full treatment in references/brainstorming.md.
Topics to cover (one question at a time, adapting to the user — see the playbook):
- What problem will the agent solve? — Core purpose and capabilities
- External APIs or data sources needed? — Tools, integrations, auth requirements
- Safety constraints? — What the agent must NOT do, guardrails
- Deployment preference? — Prototype first (recommended) or full deployment? If deploying: Agent Runtime, Cloud Run, or GKE?
Ask based on context:
- If the agent needs a capability the scaffold doesn't ship — retrieval over your data, sandboxed code execution, memory across sessions, OAuth consent, safety guardrails, event-driven triggers — that capability comes from a clone-and-study recipe, not a scaffold flag. Look the need up in the topic index in
/google-agents-cli-adk-code→references/recipes.mdand study the matching recipe in Phase 1. - If the agent is a live or voice agent (Live API, spoken conversation, barge-in, telephony) → load
/google-agents-cli-adk-code(references/adk-python-live.md) before writing the spec. Live rules out A2A, the Gemini app, and the default model. - If agent should be available to other agents → A2A protocol is built into every Python agent scaffolded by agents-cli; no separate choice needed — just scaffold normally.
- If full deployment chosen → CI/CD runner? GitHub Actions (default) or Google Cloud Build?
- If agent should remember user preferences or facts across sessions → long-term memory across conversations. Load
/google-agents-cli-adk-code— it has both the recipe (inreferences/recipes.md) and the ADK memory API details. - If Cloud Run or GKE chosen → Session storage? In-memory (default), Cloud SQL (persistent), or Sessions in Gemini platform (managed).
- If deployment with CI/CD chosen → Git repository? Does one already exist, or should one be created? If creating, public or private?
Once the design is agreed, write the spec to .agents-cli-spec.md using the template in references/spec-template.md, self-review it, then get the user's approval. See /google-agents-cli-scaffold for how these choices map to CLI flags.
Once you have a clear understanding, proceed to Phase 1.
Phase 1: Study Reference Recipes
Trigger. If the request involves any of: searching your own documents · running shell or Python code on a user's behalf · a sandboxed or isolated per-user environment · loading skills the agent picks up at runtime · work that spans days, resumes, or runs unattended · remembering across conversations · approving a risky action before it executes · blocking harmful content or moderating what agents say · acting with a user's own API keys or credentials · OAuth consent to reach a user's own data · delegating to sub-agents with isolated context · speaking A2A to other agents · reacting to events or a schedule · researching a topic online and reporting it with citations · generating images or video · monitoring a deployed agent's quality from its production traces · talking to the agent by voice in real time — then a recipe already implements it. Look it up before you commit to an implementation.
This list covers the same capabilities as the topic index in
/google-agents-cli-adk-code→references/recipes.md. If you extend one, extend the other.
Load /google-agents-cli-adk-code now.Load it even though nothing is scaffolded and you are not writing code yet; "wrong phase for the code skill" is the rationalisation that makes agents skip this step, and that skill's Prerequisites for writing code does not apply to you.
Look up each capability the design calls for. ADK Python: the topic index in
references/recipes.md maps needs (retrieval, sandboxed execution, memory, approval gates,
guardrails, per-user credentials, scheduling) to the recipe that teaches them and shows how to
clone one. ADK Go: there is no references catalog — read references/adk-go.md for the API and
the upstream examples/.
Multiple recipes can match — clone and study all that are relevant, starting with each one's AGENTS.md.
If no recipe matches, proceed to Phase 2. But first — are you sure? Re-read the user's request and re-check the topic index for your language. Skipping a matching recipe means rebuilding patterns that already exist, usually worse.
IMPORTANT — Exit criteria: After studying a recipe, ask yourself: can I apply anything from it to help me deliver the design? Note what you'll reuse before moving on. Do NOT proceed until you've answered this.
This catalog is useful at any phase — revisit it when you hit deployment, publishing, or infrastructure questions. A recipe's Terraform or registration pattern may be exactly what you need later.
Phase 2: Scaffold (if needed)
First check whether a project already exists: run agents-cli info from the project root. If one was already created or enhanced by agents-cli, skip this phase.
Otherwise, scaffold before writing any code:
- No project yet →
agents-cli scaffold create <name> --agent <template> --deployment-target <target> - Existing code to import →
agents-cli scaffold enhance .(adds the agents-cli structure)
Use /google-agents-cli-scaffold for the full workflow — it covers architecture choices (deployment target, agent type, session storage) and project creation or enhancement.
Phase 3: Build and Implement
Implement the agent logic:
- Write/modify code in the agent directory (check
GEMINI.md/CLAUDE.mdfor directory name) - Quick smoke test: Use
agents-cli run "your prompt"to verify the agent works after changes — this is the fastest way to check behavior without leaving the terminal - Iterate on the implementation based on user feedback
If the user asks for interactive testing, suggest agents-cli playground — it opens a web-based playground for manual conversation with the agent.
For ADK API patterns and code examples, use /google-agents-cli-adk-code.
Smoke-test only here — do not write behavioral unit tests. LLM output is non-deterministic; behavioral checks belong in eval (Phase 4), not in
pytestorgo test. Useagents-cli run "prompt"for quick checks.
Provision recipe infrastructure (if you adapted one)
A recipe that needs backing infrastructure (a datastore, an index, a sandbox, a queue) ships its own
provisioning: follow its Makefile (e.g. make setup-infra, make data-ingestion) and its
AGENTS.md / README.md, adapting the recipe's infra/terraform/ and .env into your project.
agents-cli has no command for this.
Phase 4: Evaluate
This is the most important phase. Evaluation validates agent behavior end-to-end.
MANDATORY: Activate /google-agents-cli-eval before running evaluation.
It contains the dataset schema, config format, and critical gotchas. Do NOT skip this.
Do NOT skip this phase. After building the agent, you MUST proceed to evaluation.
Unit tests vs agents-cli eval — know the difference:
- Unit tests (
uv run pytestfor Python,go test ./...for Go) — Tests code correctness: imports work, functions return expected types, API contracts hold. Does NOT test whether the agent behaves well. agents-cli eval— Tests agent behavior: response quality, tool usage, persona consistency, safety compliance. This is what validates your agent actually works.agents-cli run "prompt"— Quick one-off smoke test during development. If testing multiple prompts use the--start-serveroption to persist the local server, which reduces overhead for repeated calls and allows resuming local sessions via--session-id. Use this for fast iteration, not unit tests.
NEVER write unit tests that check LLM response content (e.g., asserting pirate keywords appear, checking if the agent mentions allergies). LLM outputs are non-deterministic. Use eval with LLM-as-judge criteria instead.
- Start small: Begin with 1-2 sample eval cases, not a full suite
- Run evaluations:
agents-cli eval run(chainsgenerate+grade). For debugging or custom trace locations, use the two-step form:agents-cli eval generatethenagents-cli eval grade. - Discuss results with the user
- Fix issues and iterate on the core cases first
- Only after core cases pass, add edge cases and new scenarios
- Repeat until every case meets the bar you agreed with the user. Record that bar as
thresholdsin the eval config:eval runthen ends withRESULT: PASSorRESULT: FAIL (...)and exits 1 on a miss or an errored case
Expect 5-10+ iterations here.
Phase 5: Deploy
Once the user agrees the eval scores are good enough:
- Check if the project has a deployment target configured — run
agents-cli infoto see current config - If the project is a prototype (no deployment target), add deployment support first:
Seeagents-cli scaffold enhance . --deployment-target <target>/google-agents-cli-deployfor the deployment target decision matrix (Agent Runtime vs Cloud Run vs GKE). - Deploy when ready:
agents-cli deploy
IMPORTANT: Never deploy without explicit human approval.
Phase 6: Publish (optional)
Not all agents require this — currently supporting registration with Gemini. See /google-agents-cli-publish for registration modes, flags, and troubleshooting.
Phase 7: Observe
After deploying, use observability tools to monitor agent behavior in production. See /google-agents-cli-observability for Cloud Trace, prompt-response logging, BigQuery Analytics, and third-party integrations.
Operational Guidelines for Coding Agents
Common Shortcuts to Resist
Agents routinely skip steps with plausible-sounding excuses. Recognize these and push back:
| Shortcut | Why it fails |
|---|---|
| "The user's request is clear enough, no need to clarify" | You're guessing at requirements. Phase 0 exists to confirm intent before scaffolding — even one question can prevent a full rework. |
"The agent responded correctly in agents-cli run, so eval isn't needed" |
One prompt is not a test suite. Eval catches regressions, edge cases, and tool trajectory issues that a single run never will. |
| "I'll use a newer/better model" | The scaffolded model was chosen deliberately. Changing it without being asked violates code preservation (Principle 1) and often breaks things — wrong location, deprecated version, or 404. Your training data is likely out of date — rely on the skills and the model listing command, not your knowledge of model names. |
| "I already know how to build this — sandbox, memory, approval gates" | You are about to reinvent a recipe, worse. These capabilities are already implemented and battle-tested in /google-agents-cli-adk-code → references/recipes.md; check the topic index and open the matching recipe's AGENTS.md before designing anything custom. |
| "I can skip the scaffold and set up manually" | Manual setup misses eval boilerplate, CI/CD config, and project configuration manifest conventions. Use agents-cli create even for quick experiments. |
Principle 1: Code Preservation & Isolation
Code modifications require surgical precision — alter only the code segments directly targeted by the user's request and strictly preserve all surrounding and unrelated code.
Mandatory Pre-Execution Verification:
Before finalizing any code replacement, verify the following:
- Target Identification: Clearly define the exact lines or expressions to change, based solely on the user's explicit instructions.
- Preservation Check: Confirm that all code, configuration values (e.g.,
model,version,api_key), comments, and formatting outside the identified target remain identical.
Example:
- User Request: "Change the agent's instruction to be a recipe suggester."
- Incorrect (VIOLATION):
root_agent = Agent( name="recipe_suggester", model="gemini-1.5-flash", # UNINTENDED - model was not requested to change instruction="You are a recipe suggester." ) - Correct (COMPLIANT):
root_agent = Agent( name="recipe_suggester", # OK, related to new purpose model="gemini-3.8-flash", # PRESERVED instruction="You are a recipe suggester." # OK, the direct target )
Principle 2: Execution Best Practices
-
Model Selection — CRITICAL:
- NEVER change the model unless explicitly asked.
- When creating NEW agents (not modifying existing), use the latest Gemini model. List what is available in the location your agent actually uses (
GOOGLE_CLOUD_LOCATION;globalby default) — not every model is served from every location:uv run --with google-genai python -c " from google import genai # Use your GOOGLE_CLOUD_LOCATION ('global', or a region such as 'us-east1') client = genai.Client(vertexai=True, location='global') for m in client.models.list(): print(m.name) " - Do NOT use older models unless explicitly requested. For model docs, fetch
https://adk.dev/agents/models/google-gemini/index.md. See also stable model versions and model endpoint locations.
-
Running Python Commands:
- Always use
uvto execute Python commands (e.g.,uv run python script.py) - Run
uv syncbefore executing scripts
- Always use
-
Breaking Infinite Loops:
- Stop immediately if you see the same error 3+ times in a row
- RED FLAGS: Lock IDs incrementing, names appending v5→v6→v7, "I'll try one more time" repeatedly
- State conflicts (Error 409): Use
terraform importinstead of retrying creation - When stuck: Run underlying commands directly (e.g.,
terraformCLI)
-
Troubleshooting:
- Check
/google-agents-cli-adk-codefirst — it covers most common patterns - Use WebFetch on URLs from the ADK docs index (
curl https://adk.dev/llms.txt) for deep dives - When encountering persistent errors, a targeted web search often finds solutions faster
- CLI command failures: run
agents-cli <command> --help— the output ends with aSource:line pointing to the exact source file implementing that command. Read it to understand the logic and diagnose failures. Useagents-cli infoto get the full CLI install path if you need to browse across multiple files.
- Check
Systematic Debugging
When something breaks, follow this sequence — don't skip steps or shotgun fixes:
- Reproduce — Run the exact command that failed. Save the full error output. If you can't reproduce it, you can't fix it.
- Localize — Narrow the cause: is it the agent code, a tool, the config, or the environment? Use
agents-cli run "prompt"to isolate agent behavior from deployment issues. Add-v(--verbose) to print the full JSON event payloads — useful for inspecting tool calls, intermediate steps, and silent failures. - Fix one thing — Change one variable at a time. If you change the instruction AND the tool AND the config simultaneously, you won't know what fixed it (or what broke something else).
- Verify — Rerun the exact reproduction command. Don't assume the fix worked.
- Guard — If it was a non-obvious bug, add an eval case to catch regressions.
Stop-the-line rule: If a change breaks something that was working, stop feature work and fix the regression first. Don't push forward hoping to circle back — regressions compound.
- Environment Variables:
.envfiles and env var assignments (e.g.,GOOGLE_CLOUD_PROJECT,GOOGLE_CLOUD_LOCATION) are typically required for the agent to function — never remove or modify them unless the user explicitly asks- If a
.envfile exists in the project root, treat it as essential configuration - For secrets and API keys, prefer GCP Secret Manager over plain
.enventries — see/google-agents-cli-deployfor secret management guidance
Using a Temporary Scaffold as Reference
When you need specific infrastructure files (Terraform, CI/CD, Dockerfile) but don't want to modify the current project, use /google-agents-cli-scaffold to create a temporary project in /tmp/ and copy over what you need.
Reference Files
| File | Contents |
|---|---|
references/internals.md |
Underlying tools and commands that agents-cli wraps, per language (Python: adk, uv, ruff; Go: adk-go, go, golangci-lint) |
references/spec-template.md |
.agents-cli-spec.md template and optional sections |
references/brainstorming.md |
Phase 0 design-dialogue playbook (one-at-a-time Q&A, approaches, gates) |
references/terminology.md |
Product-name → CLI-value mapping |
references/commands.md |
Per-phase agents-cli command index |
references/extension.md |
Author an ad-hoc extension or adopt an existing one (override or add commands) |
Development Commands
Run agents-cli --help or agents-cli <command> --help for the authoritative flag list. A per-phase command index lives in references/commands.md; per-phase usage is in the phase sections above.
To override a built-in command (e.g. wrap deploy with compliance checks) or add a new one, agents-cli has an extension system. To author an ad-hoc extension for this repo, or adopt an existing one, load references/extension.md.
Skills Version
Troubleshooting hint: If skills seem outdated or incomplete, reinstall:
agents-cli setup --skip-authOnly do this when you suspect stale skills are causing problems.
来源与许可
google/agents-cli 提供此 Skill,适用 Apache-2.0。本版本追加了安装和访问入口,并将相对文档链接解析为 GitHub 地址;原始文件可从下方原文入口获取。
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.