Compare commits

..

29 Commits

Author SHA1 Message Date
Rip&Tear
338662201f docs: document NL2SQL read-only enforcement and its limits
The page claimed read-only mode blocked "multi-statement queries containing
semicolons" and said nothing about CTEs, EXPLAIN ANALYZE, or the fact that a
SELECT can still reach the database server's filesystem. Both gaps matter now
that those routes are enforced.

- Replace the semicolon sentence with a table of every indirect write route
  blocked in read-only mode: multi-statement, writable CTEs (including
  AS MATERIALIZED), a write after a CTE, EXPLAIN ANALYZE, INTO OUTFILE,
  server-filesystem functions, and unparseable WITH statements.
- Explain that analysis masks literals and comments, so `SELECT 'DROP TABLE
  users'` is allowed while `EXPLAIN /*x*/ ANALYZE DELETE ...` is blocked, and
  that a semicolon inside a literal no longer splits statements.
- Document the new SET TRANSACTION READ ONLY backstop and which backends
  fall back without it.
- Add a warning that these checks are defence in depth and a least-privileged
  read-only database role is the only complete control.

Every example in the new table was verified against the implementation.
Applied to en/ar/ko/pt-BR under docs/edge; the ko and pt-BR pages carry the
warning inline as they have no Hardening Recommendations section.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-07-31 08:47:04 +08:00
Rip&Tear
7f6367a21c fix(tools): close NL2SQL read-only mode bypasses
NL2SQLTool's read-only mode could be bypassed three ways, all confirmed by
executing the validators directly.

1. `_AS_PAREN_RE` was `\bAS\s*\(`, which never matches PostgreSQL's
   `AS [NOT] MATERIALIZED (`. `WITH d AS MATERIALIZED (DELETE FROM users
   RETURNING *) SELECT * FROM d` therefore parsed as having no CTE body at
   all, and `_validate_statement` returned without running a single check.

2. `_resolve_explain_command` scanned raw text, so a comment between the
   keywords (`EXPLAIN /*x*/ ANALYZE DELETE FROM users`) stalled option
   parsing and the statement was treated as an inert EXPLAIN. EXPLAIN
   ANALYZE executes its argument.

3. The first-keyword allowlist admits statements that begin with SELECT but
   write, and those survive a transaction rollback: MySQL
   `SELECT ... INTO OUTFILE` writes a file on the DB server, and
   `pg_read_file` / `lo_import` / `dblink_exec` reach its filesystem or open
   a connection outside the transaction.

Changes:

- Analyse statements over a mask that blanks string literals, dollar-quoted
  strings, quoted identifiers and comments while preserving offsets, so a
  keyword in a literal is never matched and one behind a comment always is.
  MySQL executable comments (`/*! ... */`) are left visible because the
  server runs them.
- Match the `AS [NOT] MATERIALIZED (` spelling.
- Validate CTE bodies against an allowlist of read-only leading keywords
  instead of a write-command denylist, and fail closed: a WITH statement
  whose CTE bodies cannot be located, or which has no query after them, is
  now rejected rather than passed through.
- Block INTO OUTFILE/DUMPFILE and known server-filesystem functions.
- Mark the transaction `SET TRANSACTION READ ONLY` in read-only mode where
  the backend supports it, so enforcement no longer rests on parsing alone.
  Backends without the syntax log and fall back.
- Split statements on semicolons outside strings and comments, which also
  stops a semicolon in a literal from being rejected as multi-statement.
- Document that a least-privileged read-only DB role is the actual control
  and these checks are defence in depth.

Adds 30 regression tests. Full file: 111 passed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-07-31 08:38:07 +08:00
João Moura
112762a7fa [docs-freeze] docs: snapshot and changelog for v1.15.9 (#6726)
Some checks failed
CodeQL Advanced / Analyze (actions) (push) Has been cancelled
CodeQL Advanced / Analyze (python) (push) Has been cancelled
Check Documentation Broken Links / Check broken links (push) Has been cancelled
Vulnerability Scan / pip-audit (push) Has been cancelled
Mark stale issues and pull requests / stale (push) Has been cancelled
2026-07-30 05:45:17 +00:00
João Moura
bfe8df4471 feat: bump versions to 1.15.9 (#6725) 2026-07-29 22:40:32 -07:00
João Moura
453676c61a feat(tools): surface tool failures instead of reporting them as success (#6712)
Some checks failed
CodeQL Advanced / Analyze (actions) (push) Has been cancelled
CodeQL Advanced / Analyze (python) (push) Has been cancelled
Check Documentation Broken Links / Check broken links (push) Has been cancelled
Vulnerability Scan / pip-audit (push) Has been cancelled
Nightly Canary Release / Check for new commits (push) Has been cancelled
Nightly Canary Release / Build nightly packages (push) Has been cancelled
Nightly Canary Release / Publish nightly to PyPI (push) Has been cancelled
* feat(tools): surface tool failures instead of reporting them as success

A tool can finish without raising and still fail to do what it was asked.
Slack answers HTTP 200 with `{"ok": false, "error": "channel_not_found"}`;
an MCP server sets `isError`; a CrewAI AMP action returns
`API request failed: ...`. In every case the call "worked", so the error
text reached the agent as an ordinary result, the agent narrated the
problem in prose, and the run was recorded as a success.

Concretely: five failed `slackbot_send_message` calls each rendered as
"Tool Execution Completed", the task passed, and the crew passed -- with
the only evidence being a sentence in the final answer. Nothing
downstream could tell the difference, and an agent that keeps going on a
step that silently did nothing builds the rest of its work on it.

Give that outcome a type and a reaction:

- `ToolFailure` -- what a tool returns instead of an error string. The
  agent still reads prose via `as_agent_message()`, so model behavior is
  unchanged; the framework now knows the call failed.
- `ToolFailurePolicy` -- `ignore` (previous behavior), `warn` (default:
  record + emit, keep going), `raise` (abort with
  `ToolExecutionFailedError`). Resolved most-specific-first: tool, task,
  agent, crew.
- `ToolFailureDetectedEvent` -- emitted before a `raise` aborts, so
  subscribers always observe the failure. `ToolUsageFinishedEvent` also
  carries a `failure` field so a trace UI can mark the call failed
  without correlating two events.
- `tool_failures` on `TaskOutput`, `CrewOutput` and `LiteAgentOutput`,
  plus `has_tool_failures`, so consumers never parse a string.

Detection is strictly declarative -- no string sniffing, so a tool that
legitimately returns text about an error is never misread as failing.
Failures come from a returned `ToolFailure`, a raised exception, MCP
`isError`, a spent `max_usage_count`, or an unknown tool.

Wired into all four tool-execution paths (the ReAct path and the three
native function-calling implementations). Sources updated to report
structurally: `MCPClient.call_tool_result()` preserves `isError` that
`call_tool()` dropped, and `CrewAIPlatformActionTool` returns a
`ToolFailure` for non-2xx and for caught exceptions.

Two latent bugs fixed along the way: `ToolUsage` assumed every agent has
a `fingerprint` (LiteAgent does not), and policy resolution now tolerates
malformed values rather than letting telemetry take down a tool call.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ETacm2dMASfpMAYUiDu5YG

* fix(tools): address review round 1 on tool-failure signalling

Five real defects from Bugbot, none of them cosmetic.

Tool-scoped policy never applied (high). `resolve_tool_failure_policy`
read `tool_failure_policy` off the object handed to it, but every
execution path passes the `CrewStructuredTool` wrapper, which never
carried the attribute -- and `BaseTool` never declared it in the first
place. A tool-scoped `raise`/`ignore` was silently ignored while the
docs and a unit test claimed otherwise; the test passed only because it
called the resolver directly with an authored tool. Declared the field on
`BaseTool`, propagated it through `to_structured_tool()` and
`CrewStructuredTool`, and made resolution fall back through
`_original_tool` so either shape works.

A failed call still printed the green "Completed" panel, then the red
one. That is the terminal version of the exact bug this PR is about.
Suppressed the success panel when the call reported failure.

A raised tool printed twice: `ToolUsageErrorEvent` already renders a red
panel, and the new failure panel repeated it. The event is still emitted
-- policy and traces need it -- but the duplicate console output is gone.
Both decisions now live in named predicates on `ConsoleFormatter` rather
than inline in the listener closure, so they are directly testable.

Unknown tools were reported on the ReAct path but silently ignored on all
three native paths, so the same miss was loud or silent depending on
executor style. Native paths now record `UNKNOWN_TOOL` too. This also
surfaced a live `NameError`: ruff had pruned `ToolFailureReason` from
`agent_utils` as unused, so the new branch would have crashed at runtime.

`LiteAgentOutput` had `tool_failures` but not `has_tool_failures`, which
the PR promised on all three output types -- an `AttributeError` for any
caller sharing one check across result types.

Testing: 16 further tests, 45 total. Two console tests were passing
vacuously because `emit()` dispatches sync handlers on a thread pool, so
the assertions raced the handler; they now assert on the predicates
directly, and the native-path test drains the bus with `flush()` and
checks the synchronously-written record. Full suite still matches
baseline exactly at 377 pre-existing failures.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ETacm2dMASfpMAYUiDu5YG

* chore: update tool specifications

* fix(tools): address review round 2 and fix CI type failure

CI caught a type error I should have: widening `agent` to accept a
`LiteAgent` (so a standalone LiteAgent resolves its own policy) left the
declared signatures behind. Widened `execute_tool_and_check_finality`,
its async twin, and `ToolCallHookContext` to `Agent | BaseAgent |
LiteAgent | None`, which is what those actually receive now.

Seven CodeRabbit findings, all verified against the code first:

`raise` was being downgraded by three enclosing handlers. With
`max_execution_time` set, `_execute_with_timeout` wrapped every exception
in `RuntimeError`, so `_check_execution_error` no longer recognized the
passthrough and sent the task through the retry loop instead of aborting.
`StepExecutor.execute` turned it into `StepResult(success=False)` and let
the plan continue. `LiteAgent.kickoff` ran it through
`handle_unknown_error` and printed "This is likely a bug - please report
it" for what is a deliberate, configured stop.

Failure records were dropped on two paths. `reset_tool_failures()` only
ran in `_prepare_task_execution`, so `Agent.kickoff()` / `kickoff_async()`
— which enter through `_prepare_kickoff` — accumulated records across
runs. And a guardrail retry calls `execute_task` again, which resets the
agent, so a tool that failed on a blocked attempt vanished from the final
output entirely: a run could report zero failures having demonstrably
failed one. Failures now accumulate across guardrail attempts.

Writing the tests for that surfaced a further miss of my own:
`Agent.kickoff()` builds its `LiteAgentOutput` in `agent/core.py` via
`AgentExecutor`, not through `LiteAgent`, so `tool_failures` was always
empty there regardless of the recording fix. Wired up, and the LiteAgent
path now reads from whichever agent the executor was handed
(`original_agent` under kickoff, `self` standalone) rather than assuming.

`last_tool_failures` returns a copy, so a caller cannot mutate the
agent's record or watch it shift mid-run.

Testing: 7 further tests, 52 total, covering the timeout wrapper, the
retry limit, kickoff reset, the kickoff output path, copy semantics and
guardrail accumulation. Full suite matches baseline exactly at 377
pre-existing failures; mypy clean on every changed file.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ETacm2dMASfpMAYUiDu5YG

* fix(tools): make crew-scoped policy real and close the last raise leak

Two findings, and the first was a documented feature that never worked.

`resolve_tool_failure_policy` consulted a crew, and the docs advertised
crew as a scope, but `Crew` had no `tool_failure_policy` field at all --
and even with one it was unreachable, because `BaseAgent` defaulted the
policy to `WARN` rather than `None`, so resolution always stopped at the
agent. Crew-level configuration was silently ignored.

Fixed by making "inherit" the default everywhere instead of baking `warn`
into one layer: `Crew` gains the field, and `BaseAgent`/`LiteAgent`
default to `None` like `Task` and `BaseTool` already did. The resolver
owns the single fallback, so the chain is genuinely
tool > task > agent > crew > warn and the effective default with nothing
configured is still `warn`. Reading `agent.tool_failure_policy` now
returns `None` (meaning "inherit") rather than `WARN`.

The other: `StepExecutor` re-raised `ToolExecutionFailedError` from its
outer handler, but the nested handler around the native-to-text tooling
fallback still caught it and returned `StepResult(success=False)`. An
agent whose LLM lacked native tool calling would therefore not abort
under `raise`. That is the third distinct place this exception was being
downgraded; it now re-raises there too.

Testing: 8 further tests, 60 total, including the full precedence chain
walked one level at a time and crew-scoped `raise`/`ignore` driven
end-to-end through `kickoff()` rather than only through the resolver --
the gap that let the original crew bug pass review. Full suite matches
baseline exactly at 377 pre-existing failures; mypy clean on every
changed file.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ETacm2dMASfpMAYUiDu5YG

* docs: trim comments and docstrings on tool-failure signalling

Prose only -- no behavior change. Cut the module docstring, the longer
class and method docstrings, the multi-line inline comments, and the
verbose Field descriptions down to what actually earns its place. Net 87
lines lighter.

Kept the "why" in every case where the reason is non-obvious (why the
event fires before a raise, why the policy reads through the tool wrapper,
why the bus needs draining in tests) and dropped the restatements of what
the code already says.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ETacm2dMASfpMAYUiDu5YG

* fix(tools): make ignore truly silent, stop caching failures, close 4 gaps

Six findings from the latest review round, all verified against the code
before touching it.

`ignore` was not silent. `ToolUsageFinishedEvent.failure` was set before
the policy ran, so traces still saw a failed call under a policy documented
as surfacing nothing. Worse, the console then showed *no* panel at all:
green was suppressed because `failure` was present, red was skipped because
`ignore` never emits `ToolFailureDetectedEvent`. New `reportable_failure()`
resolves the policy before the finished event and drops the flag under
`ignore`; wired into all four execution paths.

Failures were being cached. `CacheHandler.add` stored a `ToolFailure` like
any other result, so a transient error became permanent for the rest of the
run and every later hit re-reported a call that never re-ran. The cache now
refuses to store declared failures -- fixed at the single choke point rather
than at each of the four call sites.

A spent `max_usage_count` was invisible on the shared native path.
`BaseTool._claim_usage` returned a bare string that only the executors
recognising that exact message treated as a failure. It now returns a
`ToolFailure` with `USAGE_LIMIT`, so every path records it.

A guardrail returning a whole `TaskOutput` replaced the output without
carrying accumulated failures over, so earlier attempts vanished from
`CrewOutput.tool_failures`. New `merge_tool_failures()` combines and
deduplicates, and the retry-rebuild path uses it too.

A hook-blocked call inherited a cached failure and attributed it to a call
that never ran. Now cleared. Not reachable through the built-in cache once
failures stop being cached, so the test injects a custom cache handler that
does retain them -- verified to fail without the guard.

Also removed a `datetime` import left unused by the earlier console-test
rewrite.

Testing: 13 further tests, 73 total. Full suite matches baseline exactly at
377 pre-existing failures; the usage-limit suites that `_claim_usage`
touches pass unchanged; mypy clean on every changed file.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ETacm2dMASfpMAYUiDu5YG

* fix(tools): let raise through the parallel native path, guard all handlers

Chasing down CodeRabbit's note about callers of
execute_single_native_tool_call turned up a fifth place this exception was
being downgraded: the experimental executor's parallel branch wrapped
future.result() in a broad except and folded the abort into a fake tool
result, so the remaining parallel calls carried on. The sequential path and
crew_agent_executor's parallel branch were already fine.

Five separate handlers have swallowed this during review, so added a guard
test asserting the passthrough at every site rather than trusting the next
one gets spotted.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ETacm2dMASfpMAYUiDu5YG

* fix(tools): keep a failed tool out of the final answer, finish crew scope

Three more findings, all confirmed against the code.

A failed `result_as_answer` tool still became the task's output. The native
paths already excluded raised errors and hook blocks from short-circuiting,
but not declared failures -- so an error message silently became the answer,
which is the exact shape of bug this PR exists to prevent. Fixed on all
paths, and there were three independent override points, not one:
`ToolResult.result_as_answer` in tool_utils, the `execution_result`
finality checks in both executors, and `process_tool_results()`, which
reads `agent.tools_results` back separately. The first two fixes alone left
the behavior unchanged; only the third made the test pass.

`ToolUsage` never received a crew, so a crew-level `ignore` half-applied:
recording and `ToolFailureDetectedEvent` stayed quiet, but the flag was
still attached to `ToolUsageFinishedEvent`. It now takes and stores `crew`.

`CrewAgentExecutor.invoke`/`ainvoke` routed a deliberate stop through
`handle_unknown_error`, printing "An unknown error occurred" on verbose
runs. LiteAgent already special-cased this; both now do.

Testing: 5 further tests, 79 total, including that a *successful*
`result_as_answer` tool still short-circuits. Full suite matches baseline
exactly at 377 pre-existing failures; mypy clean on every changed file.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ETacm2dMASfpMAYUiDu5YG

* fix(tools): report malformed tool args, correlate the failure event

Two findings from the latest round.

Malformed native tool arguments returned early with a plain error dict and
never reported a failure, so `ToolFailureReason.INVALID_INPUT` was declared
but unreferenced -- a bad tool call was absent from records, events and
`raise` aborts. `parse_tool_call_args` now carries an INVALID_INPUT failure
on the error dict and both executors report it before returning.

`ToolFailureDetectedEvent` never set `agent_id`, so a trace could not tie it
to a specific agent instance. Fixing that exposed the same gap running the
other way: `ToolUsage`'s own started/finished/error events never set
`agent_id` either, so on the ReAct path the paired finished event had
nothing to correlate against. Both now set it.

Set explicitly rather than via `from_agent`, which would also overwrite
`agent_role` and lose the `_original_role` preference those events already
apply -- a behavior change that has nothing to do with correlation.

Testing: 5 further tests, 84 total, asserting the ids match between the
failure event and its paired finished event. One existing test pinned the
exact key set of the parse-error dict and was updated for the new key. Full
suite matches baseline at 377 pre-existing failures; the one apparent
addition was the known `test_trace_enable_disable` order-flake, confirmed by
re-running rather than assumed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ETacm2dMASfpMAYUiDu5YG

* fix(tools): scope failure accumulation per execution, drop deprecated executor

Two review requests from @lorenzejay.

Accumulation no longer lives as mutable state on the shared agent. A
ContextVar collector is opened around each execution -- task, kickoff, and
each guardrail retry -- and the output reads that collector directly instead
of copying the agent's list. ContextVars are copied per asyncio task and per
thread, so concurrent executions cannot see each other's records, and
nesting is safe for retries. `last_tool_failures` prefers the active
collector and falls back to the last completed execution, so the accessor is
correct during a run too. The per-execution reset that caused the erasure is
gone.

Reproducing this took some digging and the finding is worth recording: crew
tasks *cannot* hit it, because `AgentExecutor` refuses concurrent reuse of
one instance and raises. `agent.kickoff()` has no such guard, and there the
bug reproduces exactly as reported -- two concurrent kickoffs each returned
two records. The regression test forces the overlap with a barrier so it is
deterministic rather than timing-dependent, and I verified it reports [2, 2]
against the old behavior and [1, 1] now.

Removed the tool-failure integration from `CrewAgentExecutor` entirely; that
file is back to its state on main. Note the shared ReAct helper it calls
still records failures, since that is common code rather than new behavior in
the deprecated file -- so a `raise` policy will be swallowed by that
executor's generic handler. Flagged on the PR rather than papered over.

Testing: 89 total. Two tests I wrote for this were vacuous on the first
attempt -- they passed against the simulated pre-fix code -- so each
concurrency test was checked against the old behavior before being kept.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ETacm2dMASfpMAYUiDu5YG

* fix(tools): report malformed calls everywhere, drop the unused block reason

Four findings.

`execute_single_native_tool_call` swallowed a JSON decode error into an empty
args dict and ran the tool with no input at all -- worse than not reporting
it. It now routes through `parse_tool_call_args` like the executors do, so
the StepExecutor/planning path reports INVALID_INPUT and returns instead of
executing. That also removes a duplicated inline parse.

The ReAct path returned a `ToolUsageError` message as an ordinary result
without reporting it, so a malformed call there was invisible while the
equivalent native failure was recorded. Now reported as INVALID_INPUT too.

`Agent.kickoff` opened a collector but no longer reset the agent-level list,
so `last_tool_failures` grew across kickoffs. Reset restored, matching task
execution.

`ToolFailureReason.BLOCKED_BY_HOOK` was declared and never produced. Rather
than start reporting hook blocks as failures, the member is removed: a block
is a deliberate decision by the hook author, and treating it as a failure
would make `raise` abort on an intentional veto. Added a guard test that every
remaining reason is actually produced somewhere, so a dead member cannot
reappear -- the same smell that flagged INVALID_INPUT last round.

Also switched the deprecation guard test to a single import style.

Testing: 6 further tests, 95 total, including that the tool does not run when
its args fail to parse. Full suite matches baseline at 377 pre-existing
failures; mypy clean.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ETacm2dMASfpMAYUiDu5YG

* fix(tools): merge failures across kickoff guardrail retries, cancel siblings

Kickoff guardrail retries discarded the blocked attempt's failures. Each
retry calls `_execute_and_build_output`, which opens a fresh collector and
builds a new output, so a run could report zero failures having demonstrably
failed one -- the same bug already fixed on the task guardrail path, which
merges. Now merged there too. Verified the test fails without the fix.

Under `raise`, one parallel native tool aborting left its siblings running:
the pool waited for them and pending ones still started. It now shuts the
pool down with `cancel_futures=True` so a not-yet-started sibling never runs.
Threads already in flight cannot be interrupted in Python, so a concurrent
tool may still complete before the abort surfaces; that is noted at the call
site rather than left implied.

Also satisfied CodeQL by materialising the enum in the guard test's loop.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ETacm2dMASfpMAYUiDu5YG

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Lorenze Jay <63378463+lorenzejay@users.noreply.github.com>
2026-07-29 19:30:14 -07:00
Lucas Gomide
d52d0a1628 feat: emit FlowFailedEvent when a flow execution fails (#6718)
Some checks failed
CodeQL Advanced / Analyze (actions) (push) Has been cancelled
CodeQL Advanced / Analyze (python) (push) Has been cancelled
Check Documentation Broken Links / Check broken links (push) Has been cancelled
Vulnerability Scan / pip-audit (push) Has been cancelled
* feat: emit FlowFailedEvent when a flow execution fails

A failed flow never emitted a terminal lifecycle event, so the
`flow_started` scope stayed open and consumers such as tracing closed the
root span with a generic orphaned message instead of the real error.
`kickoff_async` and the resume path now emit `FlowFailedEvent`, paired
with `flow_started` and carrying the exception, after draining pending
handlers and background memory writes. The resume path also emits the
`MethodExecutionStartedEvent` it was missing for the method being resumed,
so its finished or failed event pairs with its own scope instead of
popping the flow's.

* fix: skip FlowFailedEvent when the run never opened a scope

The `kickoff_async` try block starts before `FlowStartedEvent` is emitted,
so an abort in the execution-start hooks, in input handling or in state
restore emitted a `flow_failed` with no opener, which pops an unrelated
scope and warns about an empty scope stack. The failure event is now
gated on the flow scope actually being open, either from this kickoff's
`flow_started` or from a restored deferred session scope.
2026-07-29 14:44:55 -04:00
Lorenze Jay
f15844b219 Lorenze/imp/skills progressive disclosure (#6675)
Some checks failed
CodeQL Advanced / Analyze (actions) (push) Has been cancelled
CodeQL Advanced / Analyze (python) (push) Has been cancelled
Check Documentation Broken Links / Check broken links (push) Has been cancelled
Vulnerability Scan / pip-audit (push) Has been cancelled
Nightly Canary Release / Check for new commits (push) Has been cancelled
Nightly Canary Release / Build nightly packages (push) Has been cancelled
Nightly Canary Release / Publish nightly to PyPI (push) Has been cancelled
Mark stale issues and pull requests / stale (push) Has been cancelled
* skills progressive disclosure

* skills progressive disclosure

* improving progressive disclosure

* addressed comment

* fix test

---------

Co-authored-by: João Moura <joaomdmoura@gmail.com>
2026-07-28 09:33:43 -07:00
João Moura
e9caf1e1b8 [docs-freeze] docs: snapshot and changelog for v1.15.8 (#6703) 2026-07-28 15:05:44 +00:00
João Moura
133baf39b8 feat: bump versions to 1.15.8 (#6702) 2026-07-28 14:59:36 +00:00
João Moura
2e95bfb4e8 fix(tools): sandbox FileWriterTool writes and fix file tool rough edges (#6692)
Some checks failed
CodeQL Advanced / Analyze (actions) (push) Has been cancelled
CodeQL Advanced / Analyze (python) (push) Has been cancelled
Check Documentation Broken Links / Check broken links (push) Has been cancelled
Vulnerability Scan / pip-audit (push) Has been cancelled
Mark stale issues and pull requests / stale (push) Has been cancelled
* fix(tools): sandbox FileWriterTool writes and fix file tool rough edges

FileReadTool confined reads to the working directory, but FileWriterTool
only checked that `filename` stayed inside `directory` — and `directory`
itself is an LLM-supplied schema field. An agent could therefore write
anywhere the process had permission to, including ~/.ssh and site-packages,
while the reader refused to read back what the writer had just written.
FileWriterTool was the only filesystem tool in the package that did not go
through validate_file_path; files_compressor_tool validates even its
output path.

Writes are now confined to base_dir (the working directory by default):
the resolved directory must sit inside base_dir, and the resolved file
must sit inside that directory. The pre-existing filename containment
check is kept as-is and still applies even when the unsafe-paths escape
hatch is on, so no existing guarantee is weakened.

Both tools gain a base_dir field so a developer can widen the sandbox
deliberately instead of reaching for the process-wide
CREWAI_TOOLS_ALLOW_UNSAFE_PATHS kill switch. FileReadTool also stops
rejecting a file_path given to its own constructor: that is
developer-declared intent, and declaring one file does not expose its
siblings.

Also fixed:

- FileReadTool scanned the whole file when reading a line window; it now
  stops via islice once the requested lines are collected.
- FileWriterTool._run(**kwargs) made the documented positional call
  signature raise TypeError and turned a missing overwrite into
  "error accessing key". It now takes named parameters in the documented
  (filename, content, directory) order.
- A directory naming an existing file reported "already exists and
  overwrite option was not passed" even with overwrite=True; it now
  explains the real problem.
- Subdirectories inside filename are created, matching what passing
  directory already did.
- Both tools now write and decode UTF-8 by default instead of the
  platform locale encoding, with an encoding field to override. The docs
  already claimed UTF-8 and recommended the writer to Windows users.
- The writer's schema fields had no descriptions for the LLM.
- Docs claimed FileReadTool parses JSON into a dict (it never has),
  shipped a snippet that raised TypeError, and did not mention the path
  sandbox. The writer README also began with a stray "Here's the
  rewritten README" preamble.

BREAKING CHANGE: FileWriterTool no longer writes outside the working
directory. Pass base_dir to authorize a different tree.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* chore: update tool specifications

* fix(tools): make the declared FileReadTool file reachable by agents

Addresses review feedback on #6692.

The constructor-path exemption did not actually work the way an agent
calls the tool. The description only advertises a redacted label (the
basename, when the file sits outside the sandbox), but resolution
required the exact absolute path, so the model's call was sandboxed and
the declared file was never read. Worse, file_path was a required schema
field, so the long-documented "call with no arguments to read the default
file" raised a validation error instead:

    FileReadTool(file_path="/outside/declared.txt")
    .run()                          -> ValueError: validation failed
    .run(file_path="declared.txt")  -> Error: File not found
    .run(file_path="/outside/declared.txt") -> works, but the model was
                                               never told this path

file_path is now optional in the schema, so omitting it reads the default,
and the declared file is addressable by the label the description shows
the model as well as by its real path. Declaring one file still does not
expose its siblings.

The declared path is also pinned to its real path at construction, so a
later chdir cannot silently repoint it at a different file — previously a
relative constructor path re-resolved against the new working directory
on every call.

Also guards the writer's filepath resolution, which could raise
ValueError out of _run for a filename containing a null byte, breaking
the contract of always returning a descriptive string. The directory and
read paths were already guarded.

Adds docstrings to strtobool and both _run methods, corrects an Arabic
tanween spelling and a kaf-as-descriptor calque in the localized read
docs, and regenerates tool.specs.json for the schema change.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(tools): anchor the declared read path to base_dir, not the cwd

Addresses the second round of review feedback on #6692.

The previous commit pinned a relative constructor file_path with
os.path.realpath, which anchors to the working directory, while both
format_path_for_display and validate_file_path anchor a relative path to
base_dir. With the two roots disagreeing, the same relative string meant
two different files — and the tool served the cwd one under a label that
looks like it belongs to the sandbox:

    FileReadTool(file_path="data.txt", base_dir="/allowed")   # cwd=/work
    label advertised to the model -> "data.txt"
    run(file_path="data.txt")     -> contents of /work/data.txt

That reads a file from outside base_dir, so it was a sandbox escape
introduced by the exemption itself, not just a wrong-file bug.

Resolution now goes through a single _resolve_against_base helper that
anchors relative paths exactly the way the sandbox does, so the pinned
path, the advertised label and the containment check all agree. Covered
by test_relative_declared_path_anchors_to_base_dir.

Also softens "always readable" to "always allowed past the containment
check" in the docstring, README and docs, since bypassing containment
does not guarantee the read succeeds — it can still fail on a missing
file, a directory, or permissions.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(tools): tell the LLM about the path sandbox in tool descriptions

Addresses the low-confidence notes from the Copilot review on #6692.

Both tools' descriptions were pre-sandbox wording, so the model learned
about containment only by attempting a path and reading the error back.
Both now state that access is confined to the tool's allowed directory
and that a path resolving outside it is rejected.

The wording deliberately says "the tool's allowed directory" rather than
"the working directory", because the root is base_dir when one is set,
and naming the absolute root would leak it into the prompt — the same
reason paths are redacted in errors.

Not changed: the notes also suggested advertising `encoding`. That is a
constructor-only field the model cannot set, so describing it to the LLM
would be misleading.

Also fixes a test docstring that contradicted its own assertion — the
public run() path does raise on schema validation failure, which is what
the test asserts.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(tools): anchor base_dir at construction so the sandbox cannot move

Addresses the third review round on #6692.

Both remaining findings came from the same habit: storing an unanchored
string and re-resolving it later.

A relative base_dir was kept verbatim and re-resolved against getcwd() on
every call, while the declared file was pinned once at construction. After
a chdir the sandbox root moved but the declared default did not, so one
tool applied two different roots. base_dir is now resolved once — in the
reader's __init__, and via a field_validator on the writer so it also
applies on the model_validate path.

That also covers the serialization concern. model_dump drops the private
pin, and __init__ re-runs on restore, so a relative file_path was
re-anchored against whatever the working directory happened to be at load
time. With base_dir anchored, restore rebuilds the identical pin.

The residual case is a relative file_path with no base_dir, where the
sandbox root is the working directory too — so both move together and the
tool stays self-consistent. Covered by
test_declared_path_survives_a_serialization_round_trip and
test_relative_base_dir_is_anchored_at_construction on both tools.

Also corrects the writer's 'directory' description, README and docs: the
default resolves inside the tool's allowed directory, which is base_dir
when one is set, not always the working directory.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
2026-07-28 02:20:26 -07:00
João Moura
97981ed31b feat(tools): add WaitTool for pausing on long-running jobs (#6690)
Some checks failed
CodeQL Advanced / Analyze (actions) (push) Has been cancelled
CodeQL Advanced / Analyze (python) (push) Has been cancelled
Check Documentation Broken Links / Check broken links (push) Has been cancelled
Vulnerability Scan / pip-audit (push) Has been cancelled
Nightly Canary Release / Check for new commits (push) Has been cancelled
Nightly Canary Release / Build nightly packages (push) Has been cancelled
Nightly Canary Release / Publish nightly to PyPI (push) Has been cancelled
* feat(tools): add WaitTool for pausing on long-running jobs

Agents that kick off out-of-band work (a sandbox build, a deployment, an
async API job) have no way to let clock time pass: they either poll in a
tight loop or give up before the work finishes.

WaitTool pauses for a given number of seconds, with an optional reason
echoed back for traces. A single call waits at most max_seconds (default
300, configurable). Longer requests are clamped to the cap and the result
says so, so the model calls again rather than failing. Sync and async
execution are both implemented; stdlib only, no new dependencies.

The tool description spells out when to reach for it (builds, deploys,
batch jobs, async polling, backoff) and when not to, so models pick it up
for the right reason.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(tools): enforce non-negative wait on positional calls, fix doc snippets

BaseTool.run() skips args_schema validation when called with positional
arguments, so tool.run(-5) reached time.sleep(-5) and failed with an
unrelated error. _resolve_duration now enforces the seconds >= 0 contract
itself, covered for both run() and arun().

Docs and README examples are now self-contained: check_build_status_tool
is defined with the @tool decorator instead of referenced out of nowhere,
and the async example awaits inside asyncio.run() rather than at top level.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* docs: point the wait tool card at the edge path

Unprefixed links resolve against the default docs version (v1.15.7),
where the wait tool page does not exist, so the card 404'd in the broken
link check. Prefixing with /edge matches how other edge pages link.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(tools): never cache waits and keep the advertised cap accurate

Two issues from review, both confirmed against the code.

Waits inherited the default cache_function, which always allows caching.
With crew cache enabled, a repeat call with the same arguments returned
"Waited N seconds." straight from the cache without sleeping, turning a
poll-wait-check loop into a busy loop. WaitTool now declares a
cache_function that always refuses.

The description advertising the cap was only rebuilt when max_seconds
reached __init__ without an explicit description. Passing both (as a
platform building from tool.specs.json init params would), calling
model_validate, or assigning max_seconds left the text claiming 300
seconds while clamping to something else. A model_validator now derives
the description from max_seconds on construction, validation, and
assignment, and leaves a caller-supplied description untouched.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(tools): reject NaN waits and pluralize single-second results

_resolve_duration now rejects NaN with its own message instead of letting
time.sleep raise "Invalid value NaN (not a number)" from a positional
call. Infinity keeps clamping to the cap like any other oversized wait.

Result and description text no longer says "1 seconds". Tests use the
public WaitTool().description as the baseline rather than reaching for
module-private helpers.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-07-27 17:12:27 -07:00
Thiago Moretto
e2c8d7ca88 fix: mark E2B_API_KEY as a required env var for E2B tools (#6688)
E2B_API_KEY was declared with required=False on the shared E2B tool
base (E2BExecTool, E2BFileTool, E2BPythonTool), even though none of
the three tools can create or attach to a sandbox without it.
E2B_DOMAIN stays optional since it genuinely defaults to e2b.dev.

Regenerated lib/crewai-tools/tool.specs.json via
generate_tool_specs.py to reflect the change.
2026-07-27 18:31:51 +00:00
Lucas Gomide
ca5ef810be ci: check doc links only on edge and latest versions (#6633)
Some checks failed
CodeQL Advanced / Analyze (actions) (push) Has been cancelled
CodeQL Advanced / Analyze (python) (push) Has been cancelled
Vulnerability Scan / pip-audit (push) Has been cancelled
`mintlify broken-links` walks every frozen version snapshot under
`docs/` (currently 22 of them), pushing docs PR checks past 14 minutes
and growing with each release. Prune the immutable snapshots — keeping
`edge` and the default (latest) version, which unprefixed links resolve
against — before running the checker, cutting the run to ~30 seconds.
`workflow_dispatch` still checks the full tree, and the deprecated
`mintlify` CLI is swapped for `mint`, which drops the `yes` prompt hack.
2026-07-27 08:22:01 -04:00
Ossama Alami
daa7019898 docs(llms): refresh model availability guidance (#6676)
Some checks failed
CodeQL Advanced / Analyze (actions) (push) Has been cancelled
CodeQL Advanced / Analyze (python) (push) Has been cancelled
Vulnerability Scan / pip-audit (push) Has been cancelled
Check Documentation Broken Links / Check broken links (push) Has been cancelled
Nightly Canary Release / Check for new commits (push) Has been cancelled
Nightly Canary Release / Build nightly packages (push) Has been cancelled
Nightly Canary Release / Publish nightly to PyPI (push) Has been cancelled
Mark stale issues and pull requests / stale (push) Has been cancelled
* docs(llms): refresh model availability guidance

* docs: clarify structured output support

* docs: address LLM guide review feedback

* docs: refresh streaming model examples
2026-07-26 16:13:36 -07:00
João Moura
1870b444e7 [docs-freeze] docs: snapshot and changelog for v1.15.7 (#6673) 2026-07-26 11:19:47 -07:00
João Moura
38ca5edce2 feat: bump versions to 1.15.7 (#6672) 2026-07-26 18:07:46 +00:00
Lorenze Jay
213d9485fe docs: snapshot and changelog for v1.15.7a1 (#6665)
Some checks failed
CodeQL Advanced / Analyze (actions) (push) Has been cancelled
CodeQL Advanced / Analyze (python) (push) Has been cancelled
Check Documentation Broken Links / Check broken links (push) Has been cancelled
Vulnerability Scan / pip-audit (push) Has been cancelled
2026-07-26 14:04:16 -03:00
Lorenze Jay
c459d01c35 feat: bump versions to 1.15.7a1 (#6661) 2026-07-26 13:47:11 -03:00
João Moura
cc0759854d fix(skills): resolve registry skills through the runtime's CrewAI+ client (#6658)
* fix(skills): resolve registry skills through the installed AMP client

Skill downloads built their own `PlusAPI` and authenticated it from
`CREWAI_USER_PAT`, the platform integration token, or the saved CLI login.
Managed runtimes have no user credential to offer: they install a client of
their own, which `load_agent_from_repository` already resolves through, so
Agent Repository lookups worked while the skill downloads beside them failed
with 401.

Skills now resolve their client the same way, via `resolve_plus_client()` next
to the hook it reads. A client that can't fetch skills falls back to
environment credentials and warns, so older runtimes behave as they do today.
`resolve_plus_response()` shares the sync/async bridging both lookups need,
since `PlusAPI` is synchronous while managed clients are not.

Version pinning, which the same bug was hiding:

- Registry refs accept `@org/name@version`, and `@org/name@v1.2.0` since people
  write it both ways. `parse_skill_ref()` returns a `SkillRef(org, name,
  version)`; `parse_registry_ref()` keeps its `(org, name)` shape and drops the
  pin, so existing callers are unaffected
- Agent Repository agents record a version per skill, which was parsed off the
  response and dropped. Those pins now travel with the refs, so publishing a
  new version of a skill no longer changes every agent that uses it
- A pinned ref only accepts a project-local copy declaring that version in its
  `metadata.version` frontmatter, and the cache reports a miss when the version
  it recorded differs — so a pin re-resolves rather than loading another
  version. Unpinned refs keep hitting the cache as before
- An unknown pin fails instead of quietly falling back to the newest version

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(skills): reject a blank version pin instead of floating to latest

A blank `version` passed to `download_skill` read as "unpinned" and quietly
resolved the latest version, which is not what a caller supplying one asked
for — and it disagreed with `parse_skill_ref`, which already rejects empty
pins. Not reachable through `resolve_registry_ref` or the Agent Repository
auto-pinning, both of which only ever pass a non-empty version.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(skills): carry the caller's context into the worker thread

When resolve_plus_response bridges an async client from inside a running loop
it runs the coroutine on a worker thread, which starts with empty ContextVars.
A client reading runtime state there — the platform integration token, flow
context — would see defaults rather than the caller's values, which is hard to
diagnose from the resulting auth or routing failure.

Copy the context across, matching how the parallel-summarization bridge in this
module already does it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-07-26 13:27:29 -03:00
alex-clawd
bd2cb0f23e fix(openai): recover from the GPT-5.6 tools + reasoning_effort 400 (#6660)
An ordinary agent with a tool fails on the whole GPT-5.6 family:

    Agent(role=..., goal=..., backstory=...,
          llm=LLM(model="openai/gpt-5.6-sol"), tools=[multiply])

    Function tools with reasoning_effort are not supported for gpt-5.6-sol in
    /v1/chat/completions. To use function tools, use /v1/responses or set
    reasoning_effort to 'none'.

Nothing sets reasoning_effort -- not the user, not CrewAI. The family applies a
server-side default and then refuses it once tools are present. Confirmed with
raw HTTP, no CrewAI involved, on a payload with no reasoning_effort key at all:

    gpt-5.6-sol  tools, no reasoning_effort key   -> 400
    gpt-5.6-sol  tools, reasoning_effort="none"   -> OK
    gpt-5.5      tools, no reasoning_effort key   -> OK
    gpt-5.4      tools, no reasoning_effort key   -> OK
    gpt-5.2      tools, no reasoning_effort key   -> OK

So this is GPT-5.6 only, and it needs an explicit "none" -- dropping the key is
what the rejected request already looked like.

Recovered from the error rather than a model list: catch the 400, resend with
reasoning_effort="none", once. No model names, so a family OpenAI restricts later
works without a release here. Detection matches the structured `param` field plus
the message, so the unrelated "Unsupported value" 400 that o1/o3 return for
"none" isn't mistaken for this one, and the retry can't loop.

Verified against main with real agents (no reasoning_effort anywhere):

    model          no tools   tools        tools + reasoning=True
    gpt-5.6-sol    ok / ok    400 / ok     hang / ok
    gpt-5.6-terra  ok / ok    400 / ok        - / ok
    gpt-5.6-luna   ok / ok    400 / ok        - / ok
    gpt-5.5        ok         ok              -
    gpt-5.2        ok         ok           ok / ok
    gpt-4o         ok         ok              -

On main, tools + Agent(reasoning=True) produced no output and no error and was
killed at 420s; gpt-5.2 with the same config finishes in ~40s. Both the 400 and
that hang are fixed.

Tests: 15 cases, including agent definitions with tools, with tools plus
reasoning=True, and without tools. tests/llms + tests/agents -> 961 passed
(1 pre-existing unrelated failure from a local OLLAMA_API_KEY env leak).
Ruff + mypy clean.
2026-07-26 12:48:17 -03:00
alex-clawd
c52d0d9530 fix(openai): make tool calling work on the Responses API path (#6657)
* fix(openai): make tool calling work on the Responses API path

An agent with tools on api="responses" never produced an answer. It returned the
raw tool-call list instead:

    [{'id': 'call_...', 'name': 'multiply', 'arguments': '{"a":17,"b":23}'}]

Three defects in the chain, all on the Responses side only:

1. `is_tool_call_list()` knew the OpenAI-nested, Anthropic, Bedrock and Gemini
   shapes but not the Responses one ({"id", "name", "arguments"} -- no nested
   "function", no "input"). The list wasn't recognized as tool calls, so the
   executor handed it back verbatim as the final answer.

2. `extract_tool_call_info()` read "arguments" only from a nested "function"
   object, falling back to "input". For the Responses shape both missed and the
   arguments silently became {}, so the tool would have run with no input.

3. With those fixed the tool ran, then the follow-up request 400'd:

       Invalid type for 'input[1].content': expected one of an array of objects
       or string, but got null instead.

   Tool calling is expressed differently by the two APIs. Chat Completions uses an
   assistant message carrying `tool_calls` with content: None, then role: "tool"
   results. The Responses API uses flat function_call / function_call_output items
   keyed by call_id. Those messages were passed through untranslated.

`_to_responses_input()` now converts them. Messages without tool calls pass
through unchanged, so nothing else moves.

Verified end to end against the live API:

    api="responses" + tools           -> 391   (was raw tool-call JSON)
    chained multi-step tool calls     -> 400   (17*23, then +9)
    completions path (control)        -> 391   (unchanged)

The generated `input` payload was also posted to /v1/responses directly and
accepted, and the pre-fix chat-shaped payload confirmed as a 400.

This is why api="responses" never worked for agents: the provider side has had a
full Responses implementation since #4258/c4c9208, but the executor never learned
the shape it emits. Fixing it also unblocks routing gpt-5.4+ tool calls to the
Responses API instead of dropping reasoning_effort.

Tests: 12 cases covering recognition, extraction (including that the Chat
Completions and Bedrock shapes are unaffected), translation of assistant/tool
messages, parallel calls, assistant text alongside tool calls, non-string tool
output, and the full prepared `input` list.

* fix(openai): prefer Responses "call_id" over the item's own "id"

Per CodeRabbit review. A raw Responses function_call item carries both keys with
different values, confirmed against the live API:

    keys    ['arguments', 'call_id', 'id', 'name', 'status', 'type']
    id      fc_0adeb715c5d740c7006a65ccb72b948199872ad8b5a5c53108
    call_id call_dEoHFrYnOgWYvk17FymdcDZ5

function_call_output must reference call_id. Reading the item's own "id" would
produce a tool result the model can't correlate back to its invocation.

Our own _extract_function_calls_from_response already maps item.call_id into "id",
so the normal path was correct and the existing tests passed. But
extract_tool_call_info is a shared helper reached from every provider's tool loop,
and a raw Responses item is a plausible thing to hand it -- silently picking the
wrong identifier is a bad trap to leave in place for one line of guard.

Tests: raw item extraction asserting call_id is chosen over id, and a round-trip
check that the id extracted from a call is the one sent back with its result.
997 passed across tests/llms, test_agent_utils and tests/agents (1 pre-existing
unrelated failure from a local OLLAMA_API_KEY env leak). Real two-agent chained-tool
run still returns the correct answer.

---------

Co-authored-by: João Moura <joaomdmoura@gmail.com>
2026-07-26 06:18:20 -03:00
alex-clawd
b64c92c87b fix(openai): route responses-only models instead of failing with 404 (#6656)
Some checks failed
CodeQL Advanced / Analyze (actions) (push) Has been cancelled
CodeQL Advanced / Analyze (python) (push) Has been cancelled
Vulnerability Scan / pip-audit (push) Has been cancelled
Build uv cache / build-cache (3.10) (push) Has been cancelled
Build uv cache / build-cache (3.11) (push) Has been cancelled
Build uv cache / build-cache (3.12) (push) Has been cancelled
Build uv cache / build-cache (3.13) (push) Has been cancelled
Mark stale issues and pull requests / stale (push) Has been cancelled
The pro tier is not served by /v1/chat/completions. Probing the live endpoints:

    model         /v1/chat/completions   /v1/responses
    gpt-5-pro     404                    OK
    gpt-5.5-pro   404                    OK
    gpt-5.4-pro   404                    OK
    gpt-5.2-pro   404                    OK
    o1-pro        404                    OK
    o3-pro        404                    OK

Since api defaults to "completions", LLM(model="openai/gpt-5-pro") fails with
"Model ... not found", which is misleading -- the model exists, the endpoint is
wrong. OpenAI's own 404 text ("This is not a chat model") doesn't make the fix
obvious either.

These requests now route to the Responses API automatically, which is verified to
work for every model above. An explicit api= setting is always honoured.

Model matching normalizes the configured string first, so "openai/gpt-5-pro" and
"gpt-5-pro-2025-10-06" both resolve to "gpt-5-pro". It's an exact list rather
than a "-pro" substring, so a custom deployment named "gpt-4-pro-custom" isn't
swept up.

The chat-completions 404 handler also gained an actionable message: when the
response says responses-only, or the model is a known pro model, the error names
api="responses" instead of just reporting "not found".

Tests: 29 cases covering name normalization, detection, routing (including that
call() reaches the Responses handler), and both 404 message paths.
2026-07-26 06:03:09 -03:00
alex-clawd
80fa0295c4 Emit skill usage events at runtime for observability (#6652)
* feat: emit skill usage events at runtime

* test: cover skill events via execute_task paths
2026-07-26 05:04:19 -03:00
alex-clawd
728183e420 fix(deps): bump bedrock-agentcore to patch CVE-2026-16796 (#6654)
bedrock-agentcore 1.7.0 has GHSA-j6g5-3hh3-pgw8 (CVE-2026-16796, high):
argument-delimiter injection in CodeInterpreter.install_packages(). It fails
the pip-audit vulnerability scan on every PR in the repo.

The patch is 1.18.1, which requires boto3>=1.43.31. The old <1.8.0 cap plus
aiobotocore~=3.5.0 (botocore<1.42.92) made that unsatisfiable, so the AWS
stack moves together:

- bedrock-agentcore >=1.7.0,<1.8.0 -> >=1.18.1,<2.0.0
- boto3 ~=1.42.90 -> ~=1.43.46  (aws + bedrock extras)
- aiobotocore ~=3.5.0 -> ~=3.8.0 (aws + bedrock extras)

aiobotocore 3.8.0 allows botocore <1.43.47 and boto3 1.43.46 pins botocore
1.43.46, so the ranges overlap.

Verified: uv lock resolves, pip-audit reports no vulnerabilities (3 existing
ignores, none new), 48 bedrock tests pass, and both bedrock toolkits import
cleanly. BrowserClient.{start,stop,generate_ws_headers} and
CodeInterpreter.{start,stop,invoke} are unchanged in 1.18.1.
2026-07-26 04:55:05 -03:00
Lorenze Jay
b3aaaab023 [docs-freeze] docs: snapshot and changelog for v1.15.6 (#6632)
Some checks failed
Build uv cache / build-cache (3.10) (push) Has been cancelled
Build uv cache / build-cache (3.11) (push) Has been cancelled
Build uv cache / build-cache (3.12) (push) Has been cancelled
Build uv cache / build-cache (3.13) (push) Has been cancelled
CodeQL Advanced / Analyze (actions) (push) Has been cancelled
CodeQL Advanced / Analyze (python) (push) Has been cancelled
Check Documentation Broken Links / Check broken links (push) Has been cancelled
Vulnerability Scan / pip-audit (push) Has been cancelled
Nightly Canary Release / Check for new commits (push) Has been cancelled
Nightly Canary Release / Build nightly packages (push) Has been cancelled
Nightly Canary Release / Publish nightly to PyPI (push) Has been cancelled
Mark stale issues and pull requests / stale (push) Has been cancelled
2026-07-24 20:30:21 +00:00
Lorenze Jay
a4cbeacca5 feat: bump versions to 1.15.6 (#6631) 2026-07-24 20:21:58 +00:00
alex-clawd
c528e8bdee fix: detect Anthropic preview tool-use blocks (#6629)
* fix: detect anthropic preview tool-use blocks

* fix: preserve typed Anthropic tool-use blocks

* fix: bump gitpython for vulnerability scan

* docs: clarify gitpython advisory ranges

---------

Co-authored-by: Lorenze Jay <63378463+lorenzejay@users.noreply.github.com>
2026-07-24 15:32:38 -03:00
alex-clawd
c06043f7e8 fix: preserve strict tool schema property names (#6628) 2026-07-24 09:49:05 -07:00
Rip&Tear
b14d36bfe4 chore: bump json-repair to 0.60.1, drop fixed vuln ignores in scan (#6612)
Some checks failed
Build uv cache / build-cache (3.10) (push) Has been cancelled
Build uv cache / build-cache (3.11) (push) Has been cancelled
Build uv cache / build-cache (3.12) (push) Has been cancelled
Build uv cache / build-cache (3.13) (push) Has been cancelled
CodeQL Advanced / Analyze (actions) (push) Has been cancelled
CodeQL Advanced / Analyze (python) (push) Has been cancelled
Vulnerability Scan / pip-audit (push) Has been cancelled
Mark stale issues and pull requests / stale (push) Has been cancelled
Nightly Canary Release / Check for new commits (push) Has been cancelled
Nightly Canary Release / Build nightly packages (push) Has been cancelled
Nightly Canary Release / Publish nightly to PyPI (push) Has been cancelled
* chore: bump json-repair to 0.60.1 and un-ignore fixed vulns in scan

- json-repair 0.25.3 -> 0.60.1 (fixes GHSA-xf7x-x43h-rpqh)
- pyOpenSSL already at 26.2.0 in lock (covers CVE-2026-27448, CVE-2026-27459)
- remove the corresponding --ignore-vuln flags from vulnerability-scan.yml

* fix: adapt _safe_repair_json to json-repair 0.60 semantics

json-repair >= 0.60 returns an empty string for plain-text input and
wraps brace-enclosed junk in a single-element list instead of the old
""/{} sentinel values. Treat both as unrepairable so the original
tool input is preserved.

* chore: fix CI - bump gitpython/pyasn1, drop stale type ignores

- gitpython 3.1.50 -> 3.1.52 (GHSA-2f96-g7mh-g2hx, GHSA-v396-v7q4-x2qj,
  GHSA-956x-8gvw-wg5v; fixed in 3.1.51)
- pyasn1 0.6.3 -> 0.6.4 (GHSA-8ppf-4f7h-5ppj, GHSA-hm4w-wwcw-mr6r)
- json-repair 0.60 ships type stubs; remove now-unused
  type: ignore[import-untyped] comments flagged by mypy
2026-07-22 16:47:33 -07:00
4568 changed files with 992882 additions and 3593 deletions

View File

@@ -4,13 +4,11 @@ on:
pull_request:
paths:
- "docs/**"
- "docs.json"
push:
branches:
- main
paths:
- "docs/**"
- "docs.json"
workflow_dispatch:
permissions:
@@ -28,11 +26,40 @@ jobs:
with:
node-version: "22"
- name: Install Mintlify CLI
run: npm i -g mintlify
- name: Install Mint CLI
run: npm i -g mint@4.2.741
# Pruning immutable snapshots keeps the check fast (--files still parses every
# page); the default version must stay because unprefixed links resolve to it.
- name: Prune frozen doc versions (keep edge and latest)
if: github.event_name != 'workflow_dispatch'
run: |
python3 - <<'EOF'
import json
import shutil
from pathlib import Path
docs = Path("docs")
spec_path = docs / "docs.json"
spec = json.loads(spec_path.read_text())
keep_dirs = {"edge"}
for lang in spec["navigation"]["languages"]:
kept = [v for v in lang["versions"] if v["version"] == "Edge" or v.get("default")]
lang["versions"] = kept
keep_dirs.update(v["version"] for v in kept if v["version"] != "Edge")
missing = [d for d in keep_dirs if not (docs / d).is_dir()]
if missing:
raise SystemExit(f"docs.json version labels do not match directories: {missing}")
spec_path.write_text(json.dumps(spec, indent=2))
for path in docs.glob("v*"):
if path.is_dir() and path.name not in keep_dirs:
shutil.rmtree(path)
EOF
- name: Run broken link checker
run: |
# Auto-answer the prompt with yes command
yes "" | mintlify broken-links || test $? -eq 141
run: mint broken-links
working-directory: ./docs

View File

@@ -53,12 +53,9 @@ jobs:
--skip-editable
--format json
--output pip-audit-report.json
--ignore-vuln CVE-2026-27448 # pyOpenSSL: fixes require 26.0.0, blocked by snowflake-connector-python 3.x.
--ignore-vuln CVE-2026-27459 # pyOpenSSL: same constraint as CVE-2026-27448.
--ignore-vuln PYSEC-2026-597 # nltk 3.9.4 (CVE-2026-12243): no fix available, transitive through crewai-tools[xml] -> unstructured.
--ignore-vuln GHSA-rrmf-rvhw-rf47 # torch 2.12.0 (CVE-2025-3000): local-only memory corruption in torch.jit.script; no fix available.
--ignore-vuln GHSA-f4j7-r4q5-qw2c # chromadb 1.1.1 (CVE-2026-45829): pre-auth RCE in the HTTP server; no fix available.
--ignore-vuln GHSA-xf7x-x43h-rpqh # json-repair 0.25.3: the affected schema module is absent, and CrewAI does not pass schemas.
)
uv run pip-audit "${pip_audit_args[@]}"
continue-on-error: true

File diff suppressed because it is too large Load Diff

View File

@@ -4,6 +4,125 @@ description: "تحديثات المنتج والتحسينات وإصلاحات
icon: "clock"
mode: "wide"
---
<Update label="29 يوليو 2026">
## v1.15.9
[عرض الإصدار على GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.15.9)
## ما الذي تغير
### الميزات
- عرض فشل الأدوات بدلاً من الإبلاغ عنها كنجاح
- إصدار FlowFailedEvent عندما يفشل تنفيذ التدفق
- تنفيذ الكشف التدريجي للمهارات
### الوثائق
- تحديث اللقطة وسجل التغييرات للإصدار v1.15.8
## المساهمون
@github-actions[bot], @joaomdmoura, @lorenzejay, @lucasgomide
</Update>
<Update label="28 يوليو 2026">
## v1.15.8
[عرض الإصدار على GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.15.8)
## ما الذي تغير
### الميزات
- إضافة WaitTool لإيقاف التنفيذ في المهام الطويلة.
### إصلاحات الأخطاء
- إصلاح كتابات FileWriterTool ومعالجة الحواف الخشنة في أداة الملف.
- وضع E2B_API_KEY كمتغير بيئي مطلوب لأدوات E2B.
### الوثائق
- تحديث إرشادات توفر النموذج.
## المساهمون
@github-actions[bot], @joaomdmoura, @lucasgomide, @oalami, @thiagomoretto
</Update>
<Update label="26 يوليو 2026">
## v1.15.7
[عرض الإصدار على GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.15.7)
## ما الذي تغير
### إصلاحات الأخطاء
- حل مهارات السجل من خلال عميل CrewAI+ الخاص بالوقت الفعلي
- استعادة من أدوات GPT-5.6 + reasoning_effort 400
- جعل استدعاء الأدوات يعمل على مسار واجهة برمجة التطبيقات Responses
- توجيه النماذج التي تعيد الاستجابات فقط بدلاً من الفشل مع 404
- رفع bedrock-agentcore لتصحيح CVE-2026-16796
### الرصد
- إصدار أحداث استخدام المهارات في الوقت الفعلي للرصد
### الوثائق
- إضافة لقطة وتغيير السجل للإصدار v1.15.7a1
## المساهمون
@alex-clawd, @joaomdmoura, @lorenzejay
</Update>
<Update label="26 يوليو 2026">
## v1.15.7a1
[عرض الإصدار على GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.15.7a1)
## ما الذي تغير
### إصلاحات الأخطاء
- إصلاح حل مهارات السجل من خلال عميل CrewAI+ الخاص بالوقت الفعلي.
- استعادة الأداء من أخطاء أدوات GPT-5.6 وجهد الاستدلال 400.
- جعل استدعاء الأدوات يعمل على مسار واجهة برمجة التطبيقات للاستجابات.
- توجيه نماذج الاستجابات فقط لمنع أخطاء 404.
- رفع اعتماد bedrock-agentcore لإصلاح CVE-2026-16796.
### الرصد
- إصدار أحداث استخدام المهارات في الوقت الفعلي لتحسين الرصد.
### الوثائق
- تحديثات لقطة وتغيير للإصدار 1.15.6.
## المساهمون
@alex-clawd, @joaomdmoura, @lorenzejay
</Update>
<Update label="24 يوليو 2026">
## v1.15.6
[عرض الإصدار على GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.15.6)
## ما الذي تغير
### إصلاحات الأخطاء
- إصلاح الكشف عن أدوات معاينة Anthropic.
- الحفاظ على أسماء خصائص مخطط الأدوات الصارمة.
- تنفيذ حدث execution_end عند فشل تنفيذ الطاقم والتدفق.
- التعامل مع get_agent غير المتزامن في load_agent_from_repository.
- إصلاح مشكلات حل الاعتماد.
### الوثائق
- لقطة وتاريخ التغييرات للإصدار v1.15.5.
## المساهمون
@alex-clawd, @iris-clawd, @lorenzejay, @lucasgomide, @theCyberTech, @vinibrsl
</Update>
<Update label="20 يوليو 2026">
## v1.15.5

View File

@@ -157,6 +157,7 @@ class MyCustomCrew:
- **FlowCreatedEvent**: يُرسل عند إنشاء تدفق
- **FlowStartedEvent**: يُرسل عند بدء تنفيذ تدفق
- **FlowFinishedEvent**: يُرسل عند اكتمال تنفيذ تدفق
- **FlowFailedEvent**: يُرسل عند فشل تنفيذ تدفق. يحتوي على اسم التدفق والاستثناء الذي أنهى التنفيذ.
- **FlowPausedEvent**: يُرسل عند إيقاف تدفق مؤقتًا بانتظار ملاحظات بشرية
### أحداث LLM

View File

@@ -22,7 +22,7 @@ mode: "wide"
تحدد نافذة السياق مقدار النص الذي يمكن لـ LLM معالجته في وقت واحد. النوافذ الأكبر (مثل 128K رمز) تتيح سياقًا أكثر لكنها قد تكون أكثر تكلفة وأبطأ.
</Card>
<Card title="درجة الحرارة" icon="temperature-three-quarters">
تتحكم درجة الحرارة (0.0 إلى 1.0) في عشوائية الاستجابة. القيم المنخفضة (مثل 0.2) تنتج مخرجات أكثر تركيزًا وحتمية، بينما القيم الأعلى (مثل 0.8) تزيد الإبداع والتنوع.
درجة الحرارة هي أداة للتحكم في أخذ العينات تدعمها بعض النماذج. تجعل القيم المنخفضة أخذ العينات أكثر تركيزًا عمومًا، بينما تزيد القيم الأعلى التباين. تتجاهل بعض نماذج الاستدلال الأحدث هذا المعامل أو توقف دعمه أو ترفضه، لذا راجع وثائق النموذج المحدد قبل ضبطه.
</Card>
<Card title="اختيار المزود" icon="server">
يقدم كل مزود LLM (مثل OpenAI و Anthropic و Google) نماذج مختلفة بقدرات وأسعار وميزات متفاوتة. اختر بناءً على احتياجاتك من الدقة والسرعة والتكلفة.
@@ -38,7 +38,7 @@ mode: "wide"
أبسط طريقة للبدء. عيّن النموذج في بيئتك مباشرة، من خلال ملف `.env` أو في كود تطبيقك. إذا استخدمت `crewai create` لبدء مشروعك، سيكون مُعيّنًا بالفعل.
```bash .env
MODEL=model-id # e.g. gpt-4o, gemini-2.0-flash, claude-3-sonnet-...
MODEL=provider/model-id # e.g. openai/gpt-5.6-terra
# Be sure to set your API keys here too. See the Provider
# section below.
@@ -57,7 +57,7 @@ mode: "wide"
goal: Conduct comprehensive research and analysis
backstory: A dedicated research professional with years of experience
verbose: true
llm: provider/model-id # e.g. openai/gpt-4o, google/gemini-2.0-flash, anthropic/claude...
llm: provider/model-id # e.g. anthropic/claude-sonnet-4-6
# (see provider configuration examples below for more)
```
@@ -76,32 +76,24 @@ mode: "wide"
from crewai import LLM
# Basic configuration
llm = LLM(model="model-id-here") # gpt-4o, gemini-2.0-flash, anthropic/claude...
llm = LLM(model="provider/model-id") # e.g. gemini/gemini-3.6-flash
# Advanced configuration with detailed parameters
llm = LLM(
model="model-id-here", # gpt-4o, gemini-2.0-flash, anthropic/claude...
temperature=0.7, # Higher for more creative outputs
timeout=120, # Seconds to wait for response
max_tokens=4000, # Maximum length of response
top_p=0.9, # Nucleus sampling parameter
frequency_penalty=0.1 , # Reduce repetition
presence_penalty=0.1, # Encourage topic diversity
model="provider/model-id",
timeout=120,
max_tokens=4000,
response_format={"type": "json"}, # For structured outputs
seed=42 # For reproducible results
)
```
<Info>
شرح المعاملات:
- `temperature`: تتحكم في العشوائية (0.0-1.0)
- `timeout`: أقصى وقت انتظار للاستجابة
- `max_tokens`: تحدد طول الاستجابة
- `top_p`: بديل لدرجة الحرارة للعينات
- `frequency_penalty`: تقلل تكرار الكلمات
- `presence_penalty`: تشجع موضوعات جديدة
- `response_format`: تحدد هيكل المخرجات
- `seed`: تضمن مخرجات متسقة
عناصر التحكم في أخذ العينات مثل `temperature` و`top_p`، ومعاملات العقوبة، وأسماء حدود الرموز، وعناصر التحكم في الاستدلال خاصة بكل نموذج. أضفها فقط عندما يدعمها المزود والنموذج المحددان. راجع أمثلة المزودين أدناه ووثائق النموذج لدى المزود.
</Info>
</Tab>
</Tabs>
@@ -120,6 +112,10 @@ mode: "wide"
يدعم CrewAI العديد من مزودي LLM، كل منهم يقدم ميزات فريدة وطرق مصادقة وقدرات نماذج.
في هذا القسم، ستجد أمثلة مفصلة تساعدك في اختيار وإعداد وتحسين LLM الأنسب لاحتياجات مشروعك.
<Warning>
يتغير توفر النماذج باستمرار وقد يختلف حسب الحساب والمنطقة والمنصة السحابية. تستخدم الأمثلة أدناه نماذج متاحة وقت كتابة هذا الدليل، لكنها ليست قوائم دعم شاملة. قبل النشر، تحقق من معرّف النموذج وحالة دورة حياته في كتالوج المزود المرتبط.
</Warning>
<AccordionGroup>
<Accordion title="OpenAI">
يوفر CrewAI تكاملًا أصليًا مع OpenAI من خلال OpenAI Python SDK.
@@ -137,10 +133,10 @@ mode: "wide"
from crewai import LLM
llm = LLM(
model="openai/gpt-4o",
model="openai/gpt-5.6-terra",
api_key="your-api-key", # Or set OPENAI_API_KEY
temperature=0.7,
max_tokens=4000
reasoning_effort="medium",
max_completion_tokens=4000
)
```
@@ -149,25 +145,16 @@ mode: "wide"
from crewai import LLM
llm = LLM(
model="openai/gpt-4o",
model="openai/gpt-5.6-terra",
api_key="your-api-key",
base_url="https://api.openai.com/v1", # Optional custom endpoint
organization="org-...", # Optional organization ID
project="proj_...", # Optional project ID
temperature=0.7,
max_tokens=4000,
max_completion_tokens=4000, # For newer models
top_p=0.9,
frequency_penalty=0.1,
presence_penalty=0.1,
stop=["END"],
seed=42, # For reproducible outputs
max_completion_tokens=4000,
reasoning_effort="medium",
stream=True, # Enable streaming
timeout=60.0, # Request timeout in seconds
max_retries=3, # Maximum retry attempts
logprobs=True, # Return log probabilities
top_logprobs=5, # Number of most likely tokens
reasoning_effort="medium" # For o1 models: low, medium, high
max_retries=3 # Maximum retry attempts
)
```
@@ -182,7 +169,7 @@ mode: "wide"
summary: str
llm = LLM(
model="openai/gpt-4o",
model="openai/gpt-5.6-terra",
)
```
@@ -191,30 +178,15 @@ mode: "wide"
- `OPENAI_BASE_URL`: عنوان URL مخصص لـ OpenAI API (اختياري)
**الميزات:**
- دعم استدعاء الدوال الأصلي (باستثناء نماذج o1)
- دعم أصلي لاستدعاء الدوال
- مخرجات منظمة مع JSON schema
- دعم البث للاستجابات في الوقت الفعلي
- تتبع استخدام الرموز
- دعم تسلسلات التوقف (باستثناء نماذج o1)
- عناصر تحكم في التوليد خاصة بالمزود
- احتمالات السجل لرؤى على مستوى الرموز
- التحكم في جهد الاستدلال لنماذج o1
- التحكم في جهد الاستدلال للنماذج المتوافقة
**النماذج المدعومة:**
| النموذج | نافذة السياق | الأفضل لـ |
|---------------------|------------------|-----------------------------------------------|
| gpt-4.1 | 1M tokens | أحدث نموذج بقدرات محسّنة |
| gpt-4.1-mini | 1M tokens | إصدار فعال بسياق كبير |
| gpt-4.1-nano | 1M tokens | متغير فائق الكفاءة |
| gpt-4o | 128,000 tokens | محسّن للسرعة والذكاء |
| gpt-4o-mini | 200,000 tokens | فعال من حيث التكلفة بسياق كبير |
| gpt-4-turbo | 128,000 tokens | المحتوى الطويل، تحليل المستندات |
| gpt-4 | 8,192 tokens | مهام الدقة العالية، الاستدلال المعقد |
| o1 | 200,000 tokens | الاستدلال المتقدم، حل المشكلات المعقدة |
| o1-preview | 128,000 tokens | معاينة قدرات الاستدلال |
| o1-mini | 128,000 tokens | نموذج استدلال فعال |
| o3-mini | 200,000 tokens | نموذج استدلال خفيف |
| o4-mini | 200,000 tokens | استدلال فعال من الجيل التالي |
تضيف OpenAI نماذج جديدة وتسحب snapshots قديمة بانتظام. راجع [كتالوج نماذج OpenAI](https://developers.openai.com/api/docs/models) للحصول على معرّفات النماذج الحالية ونوافذ السياق وتوافق endpoints ومعلومات دورة الحياة.
**Responses API:**
@@ -276,14 +248,7 @@ mode: "wide"
)
```
جميع النماذج المدرجة هنا https://llama.developer.meta.com/docs/models/ مدعومة.
| معرّف النموذج | طول سياق الإدخال | طول سياق المخرجات | وسائط الإدخال | وسائط المخرجات |
| --- | --- | --- | --- | --- |
| `meta_llama/Llama-4-Scout-17B-16E-Instruct-FP8` | 128k | 4028 | نص، صورة | نص |
| `meta_llama/Llama-4-Maverick-17B-128E-Instruct-FP8` | 128k | 4028 | نص، صورة | نص |
| `meta_llama/Llama-3.3-70B-Instruct` | 128k | 4028 | نص | نص |
| `meta_llama/Llama-3.3-8B-Instruct` | 128k | 4028 | نص | نص |
راجع [نظرة عامة على نماذج Meta Llama](https://ai.meta.com/llama/get-started/) للتعرّف على عائلات النماذج والوسائط وإرشادات حدود السياق الحالية.
**ملاحظة:** يستخدم هذا المزود LiteLLM. أضفه كتبعية لمشروعك:
```bash
@@ -353,7 +318,7 @@ mode: "wide"
from crewai import LLM
llm = LLM(
model="anthropic/claude-3-5-sonnet-20241022",
model="anthropic/claude-sonnet-4-6",
api_key="your-api-key", # Or set ANTHROPIC_API_KEY
max_tokens=4096 # Required for Anthropic
)
@@ -364,12 +329,10 @@ mode: "wide"
from crewai import LLM
llm = LLM(
model="anthropic/claude-3-5-sonnet-20241022",
model="anthropic/claude-sonnet-4-6",
api_key="your-api-key",
base_url="https://api.anthropic.com", # Optional custom endpoint
temperature=0.7,
max_tokens=4096, # Required parameter
top_p=0.9,
stop_sequences=["END", "STOP"], # Anthropic uses stop_sequences
stream=True, # Enable streaming
timeout=60.0, # Request timeout in seconds
@@ -377,7 +340,7 @@ mode: "wide"
)
```
**التفكير الموسّع (Claude Sonnet 4 وما بعده):**
**التفكير الموسّع:**
يدعم CrewAI ميزة التفكير الموسّع من Anthropic، التي تتيح لـ Claude التفكير في المشكلات بطريقة أكثر شبهًا بالبشر قبل الاستجابة. مفيد بشكل خاص لمهام الاستدلال والتحليل وحل المشكلات المعقدة.
@@ -386,14 +349,14 @@ mode: "wide"
# Enable extended thinking with default settings
llm = LLM(
model="anthropic/claude-sonnet-4",
model="anthropic/claude-sonnet-4-6",
thinking={"type": "enabled"},
max_tokens=10000
)
# Configure thinking with budget control
llm = LLM(
model="anthropic/claude-sonnet-4",
model="anthropic/claude-sonnet-4-6",
thinking={
"type": "enabled",
"budget_tokens": 5000 # Limit thinking tokens
@@ -406,9 +369,7 @@ mode: "wide"
- `type`: عيّن إلى `"enabled"` لتفعيل وضع التفكير الموسّع
- `budget_tokens` (اختياري): أقصى رموز للتفكير (يساعد في التحكم بالتكاليف)
**النماذج التي تدعم التفكير الموسّع:**
- `claude-sonnet-4` والنماذج الأحدث
- `claude-3-7-sonnet` (مع قدرات التفكير الموسّع)
تختلف أوضاع التفكير والمعاملات المقبولة بين أجيال Claude. تحقق من قدرات النموذج المحدد قبل تفعيل `thinking`.
**متى تستخدم التفكير الموسّع:**
- الاستدلال المعقد وحل المشكلات متعددة الخطوات
@@ -424,7 +385,7 @@ mode: "wide"
**الميزات:**
- دعم استخدام الأدوات الأصلي لنماذج Claude 3+
- دعم التفكير الموسّع لـ Claude Sonnet 4+
- دعم التفكير الموسّع لنماذج Claude المتوافقة
- دعم البث للاستجابات في الوقت الفعلي
- معالجة تلقائية لرسائل النظام
- تسلسلات التوقف للتحكم في المخرجات
@@ -438,20 +399,7 @@ mode: "wide"
- يجب أن تكون الرسالة الأولى من المستخدم (يتم التعامل معها تلقائيًا)
- يجب أن تتناوب الرسائل بين المستخدم والمساعد
**النماذج المدعومة:**
| النموذج | نافذة السياق | الأفضل لـ |
|------------------------------|------------------|-----------------------------------------------|
| claude-sonnet-4 | 200,000 tokens | الأحدث مع قدرات التفكير الموسّع |
| claude-3-7-sonnet | 200,000 tokens | الاستدلال المتقدم والمهام الوكيلية |
| claude-3-5-sonnet-20241022 | 200,000 tokens | أحدث Sonnet بأفضل أداء |
| claude-3-5-haiku | 200,000 tokens | نموذج سريع وصغير للاستجابات السريعة |
| claude-3-opus | 200,000 tokens | الأكثر قدرة للمهام المعقدة |
| claude-3-sonnet | 200,000 tokens | توازن بين الذكاء والسرعة |
| claude-3-haiku | 200,000 tokens | الأسرع للمهام البسيطة |
| claude-2.1 | 200,000 tokens | سياق موسّع، هلوسات أقل |
| claude-2 | 100,000 tokens | نموذج متعدد الاستخدامات |
| claude-instant | 100,000 tokens | سريع وفعال من حيث التكلفة للمهام اليومية |
راجع [نظرة عامة على نماذج Anthropic](https://platform.claude.com/docs/en/about-claude/models/overview) للحصول على معرّفات النماذج وقدراتها الحالية، وراجع [جدول إيقاف النماذج](https://platform.claude.com/docs/en/about-claude/model-deprecations) قبل تثبيت نموذج في الإنتاج.
**ملاحظة:** لاستخدام Anthropic، ثبّت التبعيات المطلوبة:
```bash
@@ -483,9 +431,8 @@ mode: "wide"
from crewai import LLM
llm = LLM(
model="gemini/gemini-2.0-flash",
model="gemini/gemini-3.6-flash",
api_key="your-api-key", # Or set GOOGLE_API_KEY/GEMINI_API_KEY
temperature=0.7
)
```
@@ -494,11 +441,8 @@ mode: "wide"
from crewai import LLM
llm = LLM(
model="gemini/gemini-2.5-flash",
model="gemini/gemini-3.6-flash",
api_key="your-api-key",
temperature=0.7,
top_p=0.9,
top_k=40, # Top-k sampling parameter
max_output_tokens=8192,
stop_sequences=["END", "STOP"],
stream=True, # Enable streaming
@@ -524,8 +468,7 @@ mode: "wide"
from crewai import LLM
llm = LLM(
model="gemini/gemini-2.0-flash",
temperature=0.7
model="gemini/gemini-3.6-flash"
)
```
@@ -542,7 +485,7 @@ mode: "wide"
from crewai import LLM
llm = LLM(
model="gemini/gemini-1.5-pro",
model="gemini/gemini-3.6-flash",
project="your-gcp-project-id",
location="us-central1" # GCP region
)
@@ -555,7 +498,7 @@ mode: "wide"
- `GOOGLE_CLOUD_LOCATION`: موقع GCP (الافتراضي `us-central1`)
**الميزات:**
- دعم استدعاء الدوال الأصلي لنماذج Gemini 1.5+ و 2.x
- دعم أصلي لاستدعاء الدوال لنماذج Gemini المتوافقة
- دعم البث للاستجابات في الوقت الفعلي
- قدرات متعددة الوسائط (نص، صور، فيديو)
- إعداد إعدادات الأمان
@@ -563,41 +506,21 @@ mode: "wide"
- معالجة تلقائية لتعليمات النظام
- تتبع استخدام الرموز
**نماذج Gemini:**
| النموذج | نافذة السياق | الأفضل لـ |
|--------------------------------|-----------------|-------------------------------------------------------------------|
| gemini-2.5-flash | 1M tokens | التفكير التكيفي، كفاءة التكلفة |
| gemini-2.5-pro | 1M tokens | التفكير والاستدلال المحسّن، الفهم متعدد الوسائط |
| gemini-2.0-flash | 1M tokens | ميزات الجيل التالي، السرعة، التفكير |
| gemini-2.0-flash-thinking | 32,768 tokens | الاستدلال المتقدم مع عملية التفكير |
| gemini-2.0-flash-lite | 1M tokens | كفاءة التكلفة ووقت الاستجابة المنخفض |
| gemini-1.5-pro | 2M tokens | الأفضل أداءً، الاستدلال المنطقي، البرمجة |
| gemini-1.5-flash | 1M tokens | نموذج متعدد الوسائط متوازن، جيد لمعظم المهام |
| gemini-1.5-flash-8b | 1M tokens | الأسرع والأكثر كفاءة من حيث التكلفة |
| gemini-1.0-pro | 32,768 tokens | نموذج الجيل السابق |
تنشر Google معرّفات Gemini الحالية وقدراتها ومراحل دورة حياتها في [كتالوج نماذج Gemini](https://ai.google.dev/gemini-api/docs/models). تحقق من [جدول الإيقاف](https://ai.google.dev/gemini-api/docs/deprecations) قبل اختيار نموذج مستقر أو preview. وتستضيف Gemini API أيضًا [نماذج Gemma](https://ai.google.dev/gemma/docs).
**ملاحظة:** لاستخدام Google Gemini، ثبّت التبعيات المطلوبة:
```bash
uv add "crewai[google-genai]"
```
القائمة الكاملة للنماذج متاحة في [وثائق نماذج Gemini](https://ai.google.dev/gemini-api/docs/models).
</Accordion>
<Accordion title="Google (Vertex AI)">
احصل على بيانات الاعتماد من Google Cloud Console واحفظها في ملف JSON، ثم حمّلها بالكود التالي:
```python Code
import json
file_path = 'path/to/vertex_ai_service_account.json'
# Load the JSON file
with open(file_path, 'r') as file:
vertex_credentials = json.load(file)
# Convert the credentials to a JSON string
vertex_credentials_json = json.dumps(vertex_credentials)
صادِق باستخدام [بيانات الاعتماد التلقائية للتطبيق](https://cloud.google.com/docs/authentication/provide-credentials-adc)، ثم اضبط مزود Gemini الأصلي لاستخدام Vertex AI:
```toml .env
GOOGLE_GENAI_USE_VERTEXAI=true
GOOGLE_CLOUD_PROJECT=<your-project-id>
GOOGLE_CLOUD_LOCATION=<location>
```
مثال الاستخدام في مشروع CrewAI:
@@ -605,15 +528,15 @@ mode: "wide"
from crewai import LLM
llm = LLM(
model="gemini-1.5-pro-latest", # or vertex_ai/gemini-1.5-pro-latest
temperature=0.7,
vertex_credentials=vertex_credentials_json
model="gemini/gemini-3.6-flash"
)
```
**ملاحظة:** يستخدم هذا المزود LiteLLM. أضفه كتبعية لمشروعك:
تختلف إتاحة Vertex AI باختلاف المنطقة. استخدم [كتالوج نماذج Vertex AI](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models) للتحقق من معرّف النموذج والمنطقة قبل النشر.
**ملاحظة:** يستخدم هذا المسار تكامل Gemini الأصلي في CrewAI. أضفه كتبعية لمشروعك:
```bash
uv add 'crewai[litellm]'
uv add "crewai[google-genai]"
```
</Accordion>
@@ -664,7 +587,7 @@ mode: "wide"
from crewai import LLM
llm = LLM(
model="bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
model="bedrock/us.anthropic.claude-sonnet-4-6",
region_name="us-east-1"
)
```
@@ -674,7 +597,7 @@ mode: "wide"
from crewai import LLM
llm = LLM(
model="bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
model="bedrock/us.anthropic.claude-sonnet-4-6",
aws_access_key_id="your-access-key", # Or set AWS_ACCESS_KEY_ID
aws_secret_access_key="your-secret-key", # Or set AWS_SECRET_ACCESS_KEY
aws_session_token="your-session-token", # For temporary credentials
@@ -719,37 +642,9 @@ mode: "wide"
- يجب أن تكون الرسالة الأولى من المستخدم (يتم التعامل معها تلقائيًا)
- بعض النماذج (مثل Cohere) تتطلب أن تنتهي المحادثة برسالة المستخدم
[Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) هو خدمة مُدارة توفر الوصول إلى نماذج أساسية متعددة من أبرز شركات الذكاء الاصطناعي عبر واجهة API موحدة.
| النموذج | نافذة السياق | الأفضل لـ |
|-------------------------|----------------------|-------------------------------------------------------------------|
| Amazon Nova Pro | حتى 300k tokens | أداء عالٍ، نموذج يوازن بين الدقة والسرعة والفعالية من حيث التكلفة عبر مهام متنوعة. |
| Amazon Nova Micro | حتى 128k tokens | نموذج نصي فقط عالي الأداء وفعال من حيث التكلفة ومحسّن لأقل وقت استجابة. |
| Amazon Nova Lite | حتى 300k tokens | معالجة متعددة الوسائط بأسعار معقولة للصور والفيديو والنص مع قدرات في الوقت الفعلي. |
| Claude 3.7 Sonnet | حتى 128k tokens | الأفضل أداءً للاستدلال المعقد والبرمجة ووكلاء الذكاء الاصطناعي |
| Claude 3.5 Sonnet v2 | حتى 200k tokens | نموذج متطور متخصص في هندسة البرمجيات والقدرات الوكيلية والتفاعل مع الحاسوب بتكلفة محسّنة. |
| Claude 3.5 Sonnet | حتى 200k tokens | نموذج عالي الأداء يقدم ذكاءً واستدلالًا فائقين عبر مهام متنوعة مع توازن مثالي بين السرعة والتكلفة. |
| Claude 3.5 Haiku | حتى 200k tokens | نموذج متعدد الوسائط سريع وصغير محسّن للاستجابات السريعة والتفاعلات الشبيهة بالبشر |
| Claude 3 Sonnet | حتى 200k tokens | نموذج متعدد الوسائط يوازن بين الذكاء والسرعة للنشر بكميات كبيرة. |
| Claude 3 Haiku | حتى 200k tokens | نموذج متعدد الوسائط صغير وسريع محسّن للاستجابات السريعة والتفاعلات المحادثية الطبيعية |
| Claude 3 Opus | حتى 200k tokens | أكثر النماذج متعددة الوسائط تقدمًا يتفوق في المهام المعقدة بالاستدلال الشبيه بالبشر والفهم السياقي الفائق. |
| Claude 2.1 | حتى 200k tokens | إصدار محسّن بنافذة سياق موسّعة وموثوقية محسّنة وهلوسات أقل لتطبيقات النصوص الطويلة وRAG |
| Claude | حتى 100k tokens | نموذج متعدد الاستخدامات يتفوق في الحوار المتقدم والمحتوى الإبداعي واتباع التعليمات الدقيقة. |
| Claude Instant | حتى 100k tokens | نموذج سريع وفعال من حيث التكلفة للمهام اليومية مثل الحوار والتحليل والتلخيص والأسئلة والأجوبة |
| Llama 3.1 405B Instruct | حتى 128k tokens | نموذج LLM متقدم لتوليد البيانات الاصطناعية والتقطير والاستدلال لروبوتات المحادثة والبرمجة والمهام المتخصصة. |
| Llama 3.1 70B Instruct | حتى 128k tokens | يدعم المحادثات المعقدة مع فهم سياقي فائق واستدلال وتوليد نص. |
| Llama 3.1 8B Instruct | حتى 128k tokens | نموذج متطور مع فهم اللغة واستدلال فائق وتوليد النص. |
| Llama 3 70B Instruct | حتى 8k tokens | يدعم المحادثات المعقدة مع فهم سياقي فائق واستدلال وتوليد نص. |
| Llama 3 8B Instruct | حتى 8k tokens | نموذج LLM متطور مع فهم اللغة واستدلال فائق وتوليد النص. |
| Titan Text G1 - Lite | حتى 4k tokens | نموذج خفيف وفعال من حيث التكلفة محسّن لمهام اللغة الإنجليزية والضبط الدقيق مع التركيز على التلخيص وتوليد المحتوى. |
| Titan Text G1 - Express | حتى 8k tokens | نموذج متعدد الاستخدامات لمهام اللغة العامة والمحادثة وتطبيقات RAG مع دعم الإنجليزية وأكثر من 100 لغة. |
| Cohere Command | حتى 4k tokens | نموذج متخصص في اتباع أوامر المستخدم وتقديم حلول عملية للمؤسسات. |
| Jurassic-2 Mid | حتى 8,191 tokens | نموذج فعال من حيث التكلفة يوازن بين الجودة والسعر لمهام اللغة المتنوعة مثل الأسئلة والأجوبة والتلخيص وتوليد المحتوى. |
| Jurassic-2 Ultra | حتى 8,191 tokens | نموذج لتوليد النص المتقدم والفهم، يتفوق في المهام المعقدة مثل التحليل وإنشاء المحتوى. |
| Jamba-Instruct | حتى 256k tokens | نموذج بنافذة سياق موسّعة محسّن لتوليد النص الفعال من حيث التكلفة والتلخيص والأسئلة والأجوبة. |
| Mistral 7B Instruct | حتى 32k tokens | نموذج LLM يتبع التعليمات ويكمل الطلبات ويولد نصًا إبداعيًا. |
| Mistral 8x7B Instruct | حتى 32k tokens | نموذج LLM بمعمارية MOE يتبع التعليمات ويكمل الطلبات ويولد نصًا إبداعيًا. |
| DeepSeek R1 | 32,768 tokens | نموذج استدلال متقدم |
تختلف إتاحة نماذج Amazon Bedrock ومعرّفاتها باختلاف المنطقة. استخدم مرجع
[النماذج والمناطق المدعومة](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html)
لاختيار نموذج والتحقق من دعم Converse API.
**ملاحظة:** لاستخدام AWS Bedrock، ثبّت التبعيات المطلوبة:
```bash
@@ -806,81 +701,13 @@ mode: "wide"
مثال الاستخدام في مشروع CrewAI:
```python Code
llm = LLM(
model="nvidia_nim/meta/llama3-70b-instruct",
model="nvidia_nim/nvidia/nvidia-nemotron-3-ultra-550b-a55b",
temperature=0.7
)
```
يوفر Nvidia NIM مجموعة شاملة من النماذج لحالات الاستخدام المتنوعة، من المهام ذات الأغراض العامة إلى التطبيقات المتخصصة.
يتغير كتالوج NVIDIA NIM المستضاف باستمرار. استخدم [كتالوج نماذج NVIDIA NIM](https://build.nvidia.com/models) لاختيار endpoint حالي والتحقق من معرّف النموذج والوسائط وحدود السياق.
| النموذج | نافذة السياق | الأفضل لـ |
|-------------------------------------------------------------------------|----------------|-------------------------------------------------------------------|
| nvidia/mistral-nemo-minitron-8b-8k-instruct | 8,192 tokens | نموذج لغة صغير متطور يقدم دقة فائقة لروبوتات المحادثة والمساعدين الافتراضيين وتوليد المحتوى. |
| nvidia/nemotron-4-mini-hindi-4b-instruct | 4,096 tokens | نموذج لغة صغير ثنائي اللغة هندي-إنجليزي للاستدلال على الجهاز، مصمم خصيصًا للغة الهندية. |
| nvidia/llama-3.1-nemotron-70b-instruct | 128k tokens | مخصص لتعزيز فائدة الاستجابات |
| nvidia/llama3-chatqa-1.5-8b | 128k tokens | نموذج LLM متقدم لتوليد استجابات عالية الجودة ومدركة للسياق لروبوتات المحادثة ومحركات البحث. |
| nvidia/llama3-chatqa-1.5-70b | 128k tokens | نموذج LLM متقدم لتوليد استجابات عالية الجودة ومدركة للسياق لروبوتات المحادثة ومحركات البحث. |
| nvidia/vila | 128k tokens | نموذج رؤية-لغة متعدد الوسائط يفهم النص والصور والفيديو وينشئ استجابات غنية بالمعلومات |
| nvidia/neva-22 | 4,096 tokens | نموذج رؤية-لغة متعدد الوسائط يفهم النص والصور ويولد استجابات غنية بالمعلومات |
| nvidia/nemotron-mini-4b-instruct | 8,192 tokens | مهام ذات أغراض عامة |
| nvidia/usdcode-llama3-70b-instruct | 128k tokens | نموذج LLM متطور يجيب على استعلامات معرفة OpenUSD ويولد كود USD-Python. |
| nvidia/nemotron-4-340b-instruct | 4,096 tokens | ينشئ بيانات اصطناعية متنوعة تحاكي خصائص بيانات العالم الحقيقي. |
| meta/codellama-70b | 100k tokens | نموذج LLM قادر على توليد الكود من اللغة الطبيعية والعكس. |
| meta/llama2-70b | 4,096 tokens | نموذج لغة كبير متطور قادر على توليد النص والكود استجابة للمطالبات. |
| meta/llama3-8b-instruct | 8,192 tokens | نموذج LLM متطور مع فهم اللغة واستدلال فائق وتوليد النص. |
| meta/llama3-70b-instruct | 8,192 tokens | يدعم المحادثات المعقدة مع فهم سياقي فائق واستدلال وتوليد نص. |
| meta/llama-3.1-8b-instruct | 128k tokens | نموذج متطور مع فهم اللغة واستدلال فائق وتوليد النص. |
| meta/llama-3.1-70b-instruct | 128k tokens | يدعم المحادثات المعقدة مع فهم سياقي فائق واستدلال وتوليد نص. |
| meta/llama-3.1-405b-instruct | 128k tokens | نموذج LLM متقدم لتوليد البيانات الاصطناعية والتقطير والاستدلال لروبوتات المحادثة والبرمجة والمهام المتخصصة. |
| meta/llama-3.2-1b-instruct | 128k tokens | نموذج لغة صغير متطور مع فهم اللغة واستدلال فائق وتوليد النص. |
| meta/llama-3.2-3b-instruct | 128k tokens | نموذج لغة صغير متطور مع فهم اللغة واستدلال فائق وتوليد النص. |
| meta/llama-3.2-11b-vision-instruct | 128k tokens | نموذج لغة صغير متطور مع فهم اللغة واستدلال فائق وتوليد النص. |
| meta/llama-3.2-90b-vision-instruct | 128k tokens | نموذج لغة صغير متطور مع فهم اللغة واستدلال فائق وتوليد النص. |
| google/gemma-7b | 8,192 tokens | نموذج متطور لتوليد النص وفهمه وتحويله وتوليد الكود. |
| google/gemma-2b | 8,192 tokens | نموذج متطور لتوليد النص وفهمه وتحويله وتوليد الكود. |
| google/codegemma-7b | 8,192 tokens | نموذج متطور مبني على Gemma-7B من Google متخصص في توليد الكود وإكماله. |
| google/codegemma-1.1-7b | 8,192 tokens | نموذج برمجة متقدم لتوليد الكود وإكماله والاستدلال واتباع التعليمات. |
| google/recurrentgemma-2b | 8,192 tokens | نموذج لغة بمعمارية تكرارية جديدة لاستدلال أسرع عند توليد تسلسلات طويلة. |
| google/gemma-2-9b-it | 8,192 tokens | نموذج متطور لتوليد النص وفهمه وتحويله وتوليد الكود. |
| google/gemma-2-27b-it | 8,192 tokens | نموذج متطور لتوليد النص وفهمه وتحويله وتوليد الكود. |
| google/gemma-2-2b-it | 8,192 tokens | نموذج متطور لتوليد النص وفهمه وتحويله وتوليد الكود. |
| google/deplot | 512 tokens | نموذج فهم لغة بصرية بلقطة واحدة يترجم صور الرسوم البيانية إلى جداول. |
| google/paligemma | 8,192 tokens | نموذج لغة بصري بارع في استيعاب مدخلات النص والصور لإنتاج استجابات غنية بالمعلومات. |
| mistralai/mistral-7b-instruct-v0.2 | 32k tokens | نموذج LLM يتبع التعليمات ويكمل الطلبات ويولد نصًا إبداعيًا. |
| mistralai/mixtral-8x7b-instruct-v0.1 | 8,192 tokens | نموذج LLM بمعمارية MOE يتبع التعليمات ويكمل الطلبات ويولد نصًا إبداعيًا. |
| mistralai/mistral-large | 4,096 tokens | ينشئ بيانات اصطناعية متنوعة تحاكي خصائص بيانات العالم الحقيقي. |
| mistralai/mixtral-8x22b-instruct-v0.1 | 8,192 tokens | ينشئ بيانات اصطناعية متنوعة تحاكي خصائص بيانات العالم الحقيقي. |
| mistralai/mistral-7b-instruct-v0.3 | 32k tokens | نموذج LLM يتبع التعليمات ويكمل الطلبات ويولد نصًا إبداعيًا. |
| nv-mistralai/mistral-nemo-12b-instruct | 128k tokens | أكثر نموذج لغة تقدمًا للاستدلال والبرمجة والمهام متعددة اللغات؛ يعمل على وحدة GPU واحدة. |
| mistralai/mamba-codestral-7b-v0.1 | 256k tokens | نموذج للكتابة والتفاعل مع الكود عبر مجموعة واسعة من لغات البرمجة والمهام. |
| microsoft/phi-3-mini-128k-instruct | 128K tokens | نموذج LLM مفتوح خفيف ومتطور مع مهارات قوية في الرياضيات والاستدلال المنطقي. |
| microsoft/phi-3-mini-4k-instruct | 4,096 tokens | نموذج LLM مفتوح خفيف ومتطور مع مهارات قوية في الرياضيات والاستدلال المنطقي. |
| microsoft/phi-3-small-8k-instruct | 8,192 tokens | نموذج LLM مفتوح خفيف ومتطور مع مهارات قوية في الرياضيات والاستدلال المنطقي. |
| microsoft/phi-3-small-128k-instruct | 128K tokens | نموذج LLM مفتوح خفيف ومتطور مع مهارات قوية في الرياضيات والاستدلال المنطقي. |
| microsoft/phi-3-medium-4k-instruct | 4,096 tokens | نموذج LLM مفتوح خفيف ومتطور مع مهارات قوية في الرياضيات والاستدلال المنطقي. |
| microsoft/phi-3-medium-128k-instruct | 128K tokens | نموذج LLM مفتوح خفيف ومتطور مع مهارات قوية في الرياضيات والاستدلال المنطقي. |
| microsoft/phi-3.5-mini-instruct | 128K tokens | نموذج LLM خفيف متعدد اللغات يدعم تطبيقات الذكاء الاصطناعي في البيئات المحدودة بالكمون والذاكرة والحوسبة |
| microsoft/phi-3.5-moe-instruct | 128K tokens | نموذج LLM متقدم يعتمد على معمارية خليط الخبراء لتوليد محتوى فعال حوسبيًا |
| microsoft/kosmos-2 | 1,024 tokens | نموذج متعدد الوسائط رائد مصمم لفهم العناصر المرئية في الصور والاستدلال عليها. |
| microsoft/phi-3-vision-128k-instruct | 128k tokens | نموذج متعدد الوسائط مفتوح متطور يتفوق في الاستدلال عالي الجودة من الصور. |
| microsoft/phi-3.5-vision-instruct | 128k tokens | نموذج متعدد الوسائط مفتوح متطور يتفوق في الاستدلال عالي الجودة من الصور. |
| databricks/dbrx-instruct | 12k tokens | نموذج LLM للأغراض العامة بأداء متطور في فهم اللغة والبرمجة وRAG. |
| snowflake/arctic | 1,024 tokens | يقدم استدلالًا عالي الكفاءة لتطبيقات المؤسسات مع التركيز على توليد SQL والبرمجة. |
| aisingapore/sea-lion-7b-instruct | 4,096 tokens | نموذج LLM لتمثيل وخدمة التنوع اللغوي والثقافي لجنوب شرق آسيا |
| ibm/granite-8b-code-instruct | 4,096 tokens | نموذج LLM لبرمجة البرمجيات لتوليد الكود وإكماله وشرحه والتحويل متعدد الأدوار. |
| ibm/granite-34b-code-instruct | 8,192 tokens | نموذج LLM لبرمجة البرمجيات لتوليد الكود وإكماله وشرحه والتحويل متعدد الأدوار. |
| ibm/granite-3.0-8b-instruct | 4,096 tokens | نموذج لغة صغير متقدم يدعم RAG والتلخيص والتصنيف والكود والذكاء الاصطناعي الوكيلي |
| ibm/granite-3.0-3b-a800m-instruct | 4,096 tokens | نموذج خليط خبراء عالي الكفاءة لـ RAG والتلخيص واستخراج الكيانات والتصنيف |
| mediatek/breeze-7b-instruct | 4,096 tokens | ينشئ بيانات اصطناعية متنوعة تحاكي خصائص بيانات العالم الحقيقي. |
| upstage/solar-10.7b-instruct | 4,096 tokens | يتفوق في مهام NLP، خاصة في اتباع التعليمات والاستدلال والرياضيات. |
| writer/palmyra-med-70b-32k | 32k tokens | نموذج LLM رائد للاستجابات الدقيقة والمناسبة للسياق في المجال الطبي. |
| writer/palmyra-med-70b | 32k tokens | نموذج LLM رائد للاستجابات الدقيقة والمناسبة للسياق في المجال الطبي. |
| writer/palmyra-fin-70b-32k | 32k tokens | نموذج LLM متخصص في التحليل المالي وإعداد التقارير ومعالجة البيانات |
| 01-ai/yi-large | 32k tokens | نموذج قوي مدرب على الإنجليزية والصينية لمهام متنوعة بما في ذلك روبوتات المحادثة والكتابة الإبداعية. |
| deepseek-ai/deepseek-coder-6.7b-instruct | 2k tokens | نموذج برمجة قوي يقدم قدرات متقدمة في توليد الكود وإكماله وملء الفراغات |
| rakuten/rakutenai-7b-instruct | 1,024 tokens | نموذج LLM متطور مع فهم اللغة واستدلال فائق وتوليد النص. |
| rakuten/rakutenai-7b-chat | 1,024 tokens | نموذج LLM متطور مع فهم اللغة واستدلال فائق وتوليد النص. |
| baichuan-inc/baichuan2-13b-chat | 4,096 tokens | يدعم المحادثة بالصينية والإنجليزية والبرمجة والرياضيات واتباع التعليمات وحل الألغاز |
**ملاحظة:** يستخدم هذا المزود LiteLLM. أضفه كتبعية لمشروعك:
```bash
@@ -943,15 +770,12 @@ mode: "wide"
مثال الاستخدام في مشروع CrewAI:
```python Code
llm = LLM(
model="groq/llama-3.2-90b-text-preview",
model="groq/qwen/qwen3.6-27b",
temperature=0.7
)
```
| النموذج | نافذة السياق | الأفضل لـ |
|-------------------|------------------|--------------------------------------------|
| Llama 3.1 70B/8B | 131,072 tokens | مهام عالية الأداء بسياق كبير |
| Llama 3.2 Series | 8,192 tokens | مهام ذات أغراض عامة |
| Mixtral 8x7B | 32,768 tokens | أداء متوازن وسياق جيد |
تميز Groq بين نماذج production وpreview وتسحب معرّفات النماذج بانتظام. تحقق من [كتالوج نماذج Groq](https://console.groq.com/docs/models) و[صفحة الإيقاف](https://console.groq.com/docs/deprecations) قبل اختيار نموذج للإنتاج.
**ملاحظة:** يستخدم هذا المزود LiteLLM. أضفه كتبعية لمشروعك:
```bash
@@ -1033,11 +857,12 @@ mode: "wide"
مثال الاستخدام في مشروع CrewAI:
```python Code
llm = LLM(
model="llama-3.1-sonar-large-128k-online",
base_url="https://api.perplexity.ai/"
model="perplexity/sonar-pro"
)
```
راجع [كتالوج نماذج Perplexity](https://docs.perplexity.ai/getting-started/models) و[changelog](https://docs.perplexity.ai/docs/resources/changelog) للحصول على معرّفات النماذج الحالية وإشعارات الإيقاف.
**ملاحظة:** يستخدم هذا المزود LiteLLM. أضفه كتبعية لمشروعك:
```bash
uv add 'crewai[litellm]'
@@ -1073,17 +898,12 @@ mode: "wide"
مثال الاستخدام في مشروع CrewAI:
```python Code
llm = LLM(
model="sambanova/Meta-Llama-3.1-8B-Instruct",
model="sambanova/Meta-Llama-3.3-70B-Instruct",
temperature=0.7
)
```
| النموذج | نافذة السياق | الأفضل لـ |
|--------------------|------------------------|----------------------------------------------|
| Llama 3.1 70B/8B | حتى 131,072 tokens | مهام عالية الأداء بسياق كبير |
| Llama 3.1 405B | 8,192 tokens | أداء عالٍ وجودة مخرجات |
| Llama 3.2 Series | 8,192 tokens | مهام عامة ومتعددة الوسائط |
| Llama 3.3 70B | حتى 131,072 tokens | أداء عالٍ وجودة مخرجات |
| Qwen2 familly | 8,192 tokens | أداء عالٍ وجودة مخرجات |
قد تتغير النماذج المستضافة في SambaNova Cloud بصورة مستقلة عن CrewAI. استعلم من [models endpoint](https://docs.sambanova.ai/docs/api-reference/models/get-environments-available-model-list-metadata) وراجع [دليل الإيقاف](https://docs.sambanova.ai/docs/en/models/deprecations) قبل النشر.
**ملاحظة:** يستخدم هذا المزود LiteLLM. أضفه كتبعية لمشروعك:
```bash
@@ -1101,7 +921,7 @@ mode: "wide"
مثال الاستخدام في مشروع CrewAI:
```python Code
llm = LLM(
model="cerebras/llama3.1-70b",
model="cerebras/gpt-oss-120b",
temperature=0.7,
max_tokens=8192
)
@@ -1115,6 +935,8 @@ mode: "wide"
- دعم نوافذ سياق طويلة
</Info>
راجع [كتالوج نماذج Cerebras](https://inference-docs.cerebras.ai/models/overview) و[إشعارات الإيقاف](https://inference-docs.cerebras.ai/support/deprecation) للحصول على معرّفات endpoints العامة الحالية.
**ملاحظة:** يستخدم هذا المزود LiteLLM. أضفه كتبعية لمشروعك:
```bash
uv add 'crewai[litellm]'
@@ -1189,7 +1011,7 @@ mode: "wide"
# Create an LLM with streaming enabled
llm = LLM(
model="openai/gpt-4o",
model="openai/gpt-5.6-terra",
stream=True # Enable streaming
)
```
@@ -1239,7 +1061,7 @@ mode: "wide"
my_listener = MyCustomListener()
llm = LLM(model="gpt-4o-mini", temperature=0, stream=True)
llm = LLM(model="openai/gpt-5.6-terra", stream=True)
researcher = Agent(
role="About User",
@@ -1319,6 +1141,8 @@ mode: "wide"
يدعم CrewAI الاستجابات المهيكلة من استدعاءات LLM من خلال السماح لك بتحديد `response_format` باستخدام نموذج Pydantic. يمكّن هذا الإطار من تحليل المخرجات والتحقق منها تلقائيًا، مما يسهّل دمج الاستجابة في تطبيقك دون معالجة لاحقة يدوية.
يختلف دعم المخرجات المهيكلة باختلاف المزوّد والنموذج. اختبر النموذج الذي اخترته قبل الاعتماد على الاستجابات المهيكلة في بيئة الإنتاج.
```python Code
from crewai import LLM
@@ -1328,7 +1152,7 @@ class Dog(BaseModel):
breed: str
llm = LLM(model="gpt-4o", response_format=Dog)
llm = LLM(model="openai/gpt-5.6-terra", response_format=Dog)
response = llm.call(
"Analyze the following messages and return the name, age, and breed. "
@@ -1357,8 +1181,8 @@ print(response)
# 3. Task splitting for large contexts
llm = LLM(
model="gpt-4",
max_tokens=4000, # Limit response length
model="openai/gpt-5.6-terra",
max_completion_tokens=4000, # Limit response length
)
```
@@ -1382,15 +1206,14 @@ print(response)
```python
# Configure model with appropriate settings
llm = LLM(
model="openai/gpt-4-turbo-preview",
temperature=0.7, # Adjust based on task
max_tokens=4096, # Set based on output needs
timeout=300 # Longer timeout for complex tasks
model="openai/gpt-5.6-terra",
reasoning_effort="medium",
max_completion_tokens=4096,
timeout=300
)
```
<Tip>
- درجة حرارة منخفضة (0.1 إلى 0.3) للاستجابات الواقعية
- درجة حرارة عالية (0.7 إلى 0.9) للمهام الإبداعية
استخدم عناصر التحكم التي يدعمها النموذج المحدد. حسب المزود، قد تكون `temperature` أو مستوى reasoning أو thinking، أو تعليمات prompt تحدد الأسلوب والتباين المطلوبين.
</Tip>
</Step>

View File

@@ -387,26 +387,27 @@ class ContentApprovalFlow(Flow):
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| الترويسة | الوصف |
|--------|-------------|
| `X-CrewAI-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
| `X-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
#### التحقق

View File

@@ -27,6 +27,10 @@ mode: "wide"
## توصيات التقوية
<Warning>
تُعد فحوصات القراءة فقط المدمجة طبقة دفاع إضافية، وليست حدًا كاملًا. فهي تفحص نص العبارة، ولغة SQL تختلف باختلاف نظام قواعد البيانات: إذ يمكن لعبارة تبدأ بـ `SELECT` أن تصل إلى نظام ملفات خادم قاعدة البيانات (`SELECT ... INTO OUTFILE`، `pg_read_file()`) أو أن تستدعي دالة ذات آثار جانبية. تُحظر المنافذ المعروفة صراحةً، لكن التحكم الكامل الوحيد هو الصلاحيات التي تمنحها في `db_uri`. **وجّه الأداة إلى دور قاعدة بيانات للقراءة فقط بأقل الصلاحيات الممكنة.**
</Warning>
استخدم جميع الإجراءات التالية في بيئة الإنتاج:
- استخدم مستخدم قاعدة بيانات للقراءة فقط كلما أمكن
@@ -47,7 +51,21 @@ mode: "wide"
أي محاولة لتنفيذ عملية كتابة (`INSERT`، `UPDATE`، `DELETE`، `DROP`، `CREATE`، `ALTER`، `TRUNCATE`، إلخ) ستُسبب خطأً ما لم يتم تفعيل DML صراحةً.
كما تُحظر الاستعلامات متعددة العبارات التي تحتوي على فاصلة منقوطة (مثل `SELECT 1; DROP TABLE users`) في وضع القراءة فقط لمنع هجمات الحقن.
كما يحظر وضع القراءة فقط الطرق غير المباشرة للكتابة:
| المحظور في وضع القراءة فقط | مثال |
| --- | --- |
| الاستعلامات متعددة العبارات | `SELECT 1; DROP TABLE users` |
| تعبيرات CTE الكاتبة، بما في ذلك صيغة `MATERIALIZED` | `WITH d AS MATERIALIZED (DELETE FROM users RETURNING *) SELECT * FROM d` |
| عملية كتابة تلي تعبير CTE | `WITH d AS (SELECT 1) DELETE FROM users` |
| `EXPLAIN ANALYZE`، الذي ينفّذ العبارة التابعة له فعليًا | `EXPLAIN ANALYZE DELETE FROM users` |
| الكتابة إلى نظام ملفات خادم قاعدة البيانات | `SELECT * FROM users INTO OUTFILE '/var/www/shell.php'` |
| الدوال التي تصل إلى نظام ملفات الخادم أو تفتح اتصالًا جديدًا | `SELECT pg_read_file('/etc/passwd')`، `dblink_exec(...)` |
| عبارة `WITH` يتعذّر تحليلها للتأكد من أنها للقراءة فقط | `WITH d AS DELETE FROM users` |
تُحلَّل العبارات بعد إخفاء النصوص الحرفية والتعليقات، لذا لا تُعامَل كلمة مفتاحية مخبأة داخل نص حرفي على أنها أمر (`SELECT 'DROP TABLE users'` مسموح)، ولا يُخفي تعليقٌ موضوع بين الكلمات المفتاحية أمرًا (`EXPLAIN /*x*/ ANALYZE DELETE ...` محظور). كما أن الفاصلة المنقوطة داخل نص حرفي ليست فاصلًا بين العبارات، لذا فإن `SELECT ';'` عبارة واحدة صحيحة.
في وضع القراءة فقط، تضع الأداة أيضًا المعاملة في حالة `SET TRANSACTION READ ONLY`، فترفض PostgreSQL وMySQL عمليات الكتابة على مستوى قاعدة البيانات مهما كانت صياغة العبارة. أما الأنظمة التي لا تدعم هذه الصيغة (SQLite، SQL Server، Snowflake) فتُسجّل رسالة تصحيح وتعود إلى الاعتماد على فحص العبارات وحده — وهذا سبب إضافي للاعتماد على دور للقراءة فقط بدلًا من التحليل النصي.
### تفعيل عمليات الكتابة

View File

@@ -11,7 +11,7 @@ mode: "wide"
لا نزال نعمل على تحسين الأدوات، لذا قد يحدث سلوك غير متوقع أو تغييرات في المستقبل.
</Note>
تمثل أداة FileReadTool مفهومياً مجموعة من الوظائف ضمن حزمة crewai_tools تهدف إلى تسهيل قراءة الملفات واسترجاع المحتوى. تتضمن هذه المجموعة أدوات لمعالجة ملفات نصية دفعية، وقراءة ملفات التكوين أثناء التشغيل، واستيراد البيانات للتحليلات. تدعم مجموعة متنوعة من صيغ الملفات النصية مثل `.txt` و `.csv` و `.json` وغيرها. اعتماداً على نوع الملف، توفر المجموعة وظائف متخصصة، مثل تحويل محتوى JSON إلى قاموس Python لسهولة الاستخدام.
تمثل أداة FileReadTool مفهوميًا مجموعة من الوظائف ضمن حزمة crewai_tools تهدف إلى تسهيل قراءة الملفات واسترجاع المحتوى. تتضمن هذه المجموعة أدوات لمعالجة ملفات نصية دفعية، وقراءة ملفات التكوين أثناء التشغيل، واستيراد البيانات للتحليلات. تدعم مجموعة متنوعة من صيغ الملفات النصية مثل `.txt` و `.csv` و `.json` وغيرها. يُعاد المحتوى دائمًا نصًا عاديًا.
## التثبيت

View File

@@ -30,7 +30,11 @@ from crewai_tools import FileWriterTool
file_writer_tool = FileWriterTool()
# Write content to a file in a specified directory
result = file_writer_tool._run('example.txt', 'This is a test content.', 'test_directory')
result = file_writer_tool.run(
filename='example.txt',
content='This is a test content.',
directory='test_directory',
)
print(result)
```

View File

@@ -4,6 +4,125 @@ description: "Product updates, improvements, and bug fixes for CrewAI"
icon: "clock"
mode: "wide"
---
<Update label="Jul 29, 2026">
## v1.15.9
[View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.15.9)
## What's Changed
### Features
- Surface tool failures instead of reporting them as success
- Emit FlowFailedEvent when a flow execution fails
- Implement progressive disclosure for skills
### Documentation
- Update snapshot and changelog for v1.15.8
## Contributors
@github-actions[bot], @joaomdmoura, @lorenzejay, @lucasgomide
</Update>
<Update label="Jul 28, 2026">
## v1.15.8
[View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.15.8)
## What's Changed
### Features
- Add WaitTool for pausing on long-running jobs.
### Bug Fixes
- Fix FileWriterTool writes and address rough edges in file tool.
- Mark E2B_API_KEY as a required env var for E2B tools.
### Documentation
- Refresh model availability guidance.
## Contributors
@github-actions[bot], @joaomdmoura, @lucasgomide, @oalami, @thiagomoretto
</Update>
<Update label="Jul 26, 2026">
## v1.15.7
[View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.15.7)
## What's Changed
### Bug Fixes
- Resolve registry skills through the runtime's CrewAI+ client
- Recover from the GPT-5.6 tools + reasoning_effort 400
- Make tool calling work on the Responses API path
- Route responses-only models instead of failing with 404
- Bump bedrock-agentcore to patch CVE-2026-16796
### Observability
- Emit skill usage events at runtime for observability
### Documentation
- Add snapshot and changelog for v1.15.7a1
## Contributors
@alex-clawd, @joaomdmoura, @lorenzejay
</Update>
<Update label="Jul 26, 2026">
## v1.15.7a1
[View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.15.7a1)
## What's Changed
### Bug Fixes
- Fix registry skills resolution through the runtime's CrewAI+ client.
- Recover from the GPT-5.6 tools and reasoning_effort 400 errors.
- Make tool calling work on the Responses API path.
- Route responses-only models to prevent 404 errors.
- Bump bedrock-agentcore dependency to patch CVE-2026-16796.
### Observability
- Emit skill usage events at runtime for improved observability.
### Documentation
- Snapshot and changelog updates for version 1.15.6.
## Contributors
@alex-clawd, @joaomdmoura, @lorenzejay
</Update>
<Update label="Jul 24, 2026">
## v1.15.6
[View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.15.6)
## What's Changed
### Bug Fixes
- Fix detection of Anthropic preview tool-use blocks.
- Preserve strict tool schema property names.
- Dispatch execution_end hook on failed crew and flow executions.
- Handle async get_agent in load_agent_from_repository.
- Fix dependency resolution issues.
### Documentation
- Snapshot and changelog for v1.15.5.
## Contributors
@alex-clawd, @iris-clawd, @lorenzejay, @lucasgomide, @theCyberTech, @vinibrsl
</Update>
<Update label="Jul 20, 2026">
## v1.15.5

View File

@@ -256,6 +256,7 @@ CrewAI provides a wide range of events that you can listen for:
- **FlowCreatedEvent**: Emitted when a Flow is created
- **FlowStartedEvent**: Emitted when a Flow starts execution
- **FlowFinishedEvent**: Emitted when a Flow completes execution
- **FlowFailedEvent**: Emitted when a Flow execution fails. Contains the flow name and the exception that ended the execution.
- **FlowPausedEvent**: Emitted when a Flow is paused waiting for human feedback. Contains the flow name, flow ID, method name, current state, message shown when requesting feedback, and optional list of possible outcomes for routing.
- **FlowPlotEvent**: Emitted when a Flow is plotted
- **MethodExecutionStartedEvent**: Emitted when a Flow method starts execution

View File

@@ -22,7 +22,10 @@ Large Language Models (LLMs) are the core intelligence behind CrewAI agents. The
The context window determines how much text an LLM can process at once. Larger windows (e.g., 128K tokens) allow for more context but may be more expensive and slower.
</Card>
<Card title="Temperature" icon="temperature-three-quarters">
Temperature (0.0 to 1.0) controls response randomness. Lower values (e.g., 0.2) produce more focused, deterministic outputs, while higher values (e.g., 0.8) increase creativity and variability.
Temperature is a sampling control supported by some models. Lower values
generally make sampling more focused, while higher values increase
variability. Some newer reasoning models ignore, deprecate, or reject this
parameter, so check the selected model's documentation before setting it.
</Card>
<Card title="Provider Selection" icon="server">
Each LLM provider (e.g., OpenAI, Anthropic, Google) offers different models with varying capabilities, pricing, and features. Choose based on your needs for accuracy, speed, and cost.
@@ -38,7 +41,7 @@ There are different places in CrewAI code where you can specify the model to use
The simplest way to get started. Set the model in your environment directly, through an `.env` file or in your app code. If you used `crewai create` to bootstrap your project, it will be set already.
```bash .env
MODEL=model-id # e.g. gpt-4o, gemini-2.0-flash, claude-3-sonnet-...
MODEL=provider/model-id # e.g. openai/gpt-5.6-terra
# Be sure to set your API keys here too. See the Provider
# section below.
@@ -57,7 +60,7 @@ There are different places in CrewAI code where you can specify the model to use
goal: Conduct comprehensive research and analysis
backstory: A dedicated research professional with years of experience
verbose: true
llm: provider/model-id # e.g. openai/gpt-4o, google/gemini-2.0-flash, anthropic/claude...
llm: provider/model-id # e.g. anthropic/claude-sonnet-4-6
# (see provider configuration examples below for more)
```
@@ -76,32 +79,27 @@ There are different places in CrewAI code where you can specify the model to use
from crewai import LLM
# Basic configuration
llm = LLM(model="model-id-here") # gpt-4o, gemini-2.0-flash, anthropic/claude...
llm = LLM(model="provider/model-id") # e.g. gemini/gemini-3.6-flash
# Advanced configuration with detailed parameters
llm = LLM(
model="model-id-here", # gpt-4o, gemini-2.0-flash, anthropic/claude...
temperature=0.7, # Higher for more creative outputs
timeout=120, # Seconds to wait for response
max_tokens=4000, # Maximum length of response
top_p=0.9, # Nucleus sampling parameter
frequency_penalty=0.1 , # Reduce repetition
presence_penalty=0.1, # Encourage topic diversity
model="provider/model-id",
timeout=120,
max_tokens=4000,
response_format={"type": "json"}, # For structured outputs
seed=42 # For reproducible results
)
```
<Info>
Parameter explanations:
- `temperature`: Controls randomness (0.0-1.0)
- `timeout`: Maximum wait time for response
- `max_tokens`: Limits response length
- `top_p`: Alternative to temperature for sampling
- `frequency_penalty`: Reduces word repetition
- `presence_penalty`: Encourages new topics
- `response_format`: Specifies output structure
- `seed`: Ensures consistent outputs
Sampling controls such as `temperature` and `top_p`, penalty parameters,
token-limit names, and reasoning controls are model-specific. Add them
only when the selected provider and model support them. See the provider
examples below and the provider's model documentation.
</Info>
</Tab>
</Tabs>
@@ -120,6 +118,13 @@ There are different places in CrewAI code where you can specify the model to use
CrewAI supports a multitude of LLM providers, each offering unique features, authentication methods, and model capabilities.
In this section, you'll find detailed examples that help you select, configure, and optimize the LLM that best fits your project's needs.
<Warning>
Model availability changes frequently and can vary by account, region, and
cloud platform. The examples below use models that are current at the time of
writing, but they are not exhaustive support lists. Before deploying, verify
the model ID and lifecycle status in the provider's linked model catalog.
</Warning>
<AccordionGroup>
<Accordion title="OpenAI">
CrewAI provides native integration with OpenAI through the OpenAI Python SDK.
@@ -137,10 +142,10 @@ In this section, you'll find detailed examples that help you select, configure,
from crewai import LLM
llm = LLM(
model="openai/gpt-4o",
model="openai/gpt-5.6-terra",
api_key="your-api-key", # Or set OPENAI_API_KEY
temperature=0.7,
max_tokens=4000
reasoning_effort="medium",
max_completion_tokens=4000
)
```
@@ -161,25 +166,16 @@ In this section, you'll find detailed examples that help you select, configure,
from crewai import LLM
llm = LLM(
model="openai/gpt-4o",
model="openai/gpt-5.6-terra",
api_key="your-api-key",
base_url="https://api.openai.com/v1", # Optional custom endpoint
organization="org-...", # Optional organization ID
project="proj_...", # Optional project ID
temperature=0.7,
max_tokens=4000,
max_completion_tokens=4000, # For newer models
top_p=0.9,
frequency_penalty=0.1,
presence_penalty=0.1,
stop=["END"],
seed=42, # For reproducible outputs
max_completion_tokens=4000,
reasoning_effort="medium",
stream=True, # Enable streaming
timeout=60.0, # Request timeout in seconds
max_retries=3, # Maximum retry attempts
logprobs=True, # Return log probabilities
top_logprobs=5, # Number of most likely tokens
reasoning_effort="medium" # For o1 models: low, medium, high
max_retries=3 # Maximum retry attempts
)
```
@@ -194,7 +190,7 @@ In this section, you'll find detailed examples that help you select, configure,
summary: str
llm = LLM(
model="openai/gpt-4o",
model="openai/gpt-5.6-terra",
)
```
@@ -203,30 +199,18 @@ In this section, you'll find detailed examples that help you select, configure,
- `OPENAI_BASE_URL`: Custom base URL for OpenAI API (optional)
**Features:**
- Native function calling support (except o1 models)
- Native function calling support
- Structured outputs with JSON schema
- Streaming support for real-time responses
- Token usage tracking
- Stop sequences support (except o1 models)
- Provider-specific generation controls
- Log probabilities for token-level insights
- Reasoning effort control for o1 models
- Reasoning effort control for supported models
**Supported Models:**
| Model | Context Window | Best For |
|---------------------|------------------|-----------------------------------------------|
| gpt-4.1 | 1M tokens | Latest model with enhanced capabilities |
| gpt-4.1-mini | 1M tokens | Efficient version with large context |
| gpt-4.1-nano | 1M tokens | Ultra-efficient variant |
| gpt-4o | 128,000 tokens | Optimized for speed and intelligence |
| gpt-4o-mini | 200,000 tokens | Cost-effective with large context |
| gpt-4-turbo | 128,000 tokens | Long-form content, document analysis |
| gpt-4 | 8,192 tokens | High-accuracy tasks, complex reasoning |
| o1 | 200,000 tokens | Advanced reasoning, complex problem-solving |
| o1-preview | 128,000 tokens | Preview of reasoning capabilities |
| o1-mini | 128,000 tokens | Efficient reasoning model |
| o3-mini | 200,000 tokens | Lightweight reasoning model |
| o4-mini | 200,000 tokens | Next-gen efficient reasoning |
OpenAI regularly adds models and retires older snapshots. See the
[OpenAI model catalog](https://developers.openai.com/api/docs/models) for
current model IDs, context windows, endpoint compatibility, and lifecycle
information.
**Responses API:**
@@ -288,14 +272,8 @@ In this section, you'll find detailed examples that help you select, configure,
)
```
All models listed here https://llama.developer.meta.com/docs/models/ are supported.
| Model ID | Input context length | Output context length | Input Modalities | Output Modalities |
| --- | --- | --- | --- | --- |
| `meta_llama/Llama-4-Scout-17B-16E-Instruct-FP8` | 128k | 4028 | Text, Image | Text |
| `meta_llama/Llama-4-Maverick-17B-128E-Instruct-FP8` | 128k | 4028 | Text, Image | Text |
| `meta_llama/Llama-3.3-70B-Instruct` | 128k | 4028 | Text | Text |
| `meta_llama/Llama-3.3-8B-Instruct` | 128k | 4028 | Text | Text |
See the [Meta Llama model overview](https://ai.meta.com/llama/get-started/)
for current model families, modalities, and context guidance.
**Note:** This provider uses LiteLLM. Add it as a dependency to your project:
```bash
@@ -365,7 +343,7 @@ In this section, you'll find detailed examples that help you select, configure,
from crewai import LLM
llm = LLM(
model="anthropic/claude-3-5-sonnet-20241022",
model="anthropic/claude-sonnet-4-6",
api_key="your-api-key", # Or set ANTHROPIC_API_KEY
max_tokens=4096 # Required for Anthropic
)
@@ -376,12 +354,10 @@ In this section, you'll find detailed examples that help you select, configure,
from crewai import LLM
llm = LLM(
model="anthropic/claude-3-5-sonnet-20241022",
model="anthropic/claude-sonnet-4-6",
api_key="your-api-key",
base_url="https://api.anthropic.com", # Optional custom endpoint
temperature=0.7,
max_tokens=4096, # Required parameter
top_p=0.9,
stop_sequences=["END", "STOP"], # Anthropic uses stop_sequences
stream=True, # Enable streaming
timeout=60.0, # Request timeout in seconds
@@ -389,7 +365,7 @@ In this section, you'll find detailed examples that help you select, configure,
)
```
**Extended Thinking (Claude Sonnet 4 and Beyond):**
**Extended Thinking:**
CrewAI supports Anthropic's Extended Thinking feature, which allows Claude to think through problems in a more human-like way before responding. This is particularly useful for complex reasoning, analysis, and problem-solving tasks.
@@ -398,14 +374,14 @@ In this section, you'll find detailed examples that help you select, configure,
# Enable extended thinking with default settings
llm = LLM(
model="anthropic/claude-sonnet-4",
model="anthropic/claude-sonnet-4-6",
thinking={"type": "enabled"},
max_tokens=10000
)
# Configure thinking with budget control
llm = LLM(
model="anthropic/claude-sonnet-4",
model="anthropic/claude-sonnet-4-6",
thinking={
"type": "enabled",
"budget_tokens": 5000 # Limit thinking tokens
@@ -418,9 +394,8 @@ In this section, you'll find detailed examples that help you select, configure,
- `type`: Set to `"enabled"` to activate extended thinking mode
- `budget_tokens` (optional): Maximum tokens to use for thinking (helps control costs)
**Models Supporting Extended Thinking:**
- `claude-sonnet-4` and newer models
- `claude-3-7-sonnet` (with extended thinking capabilities)
Thinking modes and accepted parameters vary across Claude generations.
Check the selected model's capabilities before enabling `thinking`.
**When to Use Extended Thinking:**
- Complex reasoning and multi-step problem solving
@@ -436,7 +411,7 @@ In this section, you'll find detailed examples that help you select, configure,
**Features:**
- Native tool use support for Claude 3+ models
- Extended Thinking support for Claude Sonnet 4+
- Extended Thinking support for compatible Claude models
- Streaming support for real-time responses
- Automatic system message handling
- Stop sequences for controlled output
@@ -450,20 +425,10 @@ In this section, you'll find detailed examples that help you select, configure,
- First message must be from the user (automatically handled)
- Messages must alternate between user and assistant
**Supported Models:**
| Model | Context Window | Best For |
|------------------------------|----------------|-----------------------------------------------|
| claude-sonnet-4 | 200,000 tokens | Latest with extended thinking capabilities |
| claude-3-7-sonnet | 200,000 tokens | Advanced reasoning and agentic tasks |
| claude-3-5-sonnet-20241022 | 200,000 tokens | Latest Sonnet with best performance |
| claude-3-5-haiku | 200,000 tokens | Fast, compact model for quick responses |
| claude-3-opus | 200,000 tokens | Most capable for complex tasks |
| claude-3-sonnet | 200,000 tokens | Balanced intelligence and speed |
| claude-3-haiku | 200,000 tokens | Fastest for simple tasks |
| claude-2.1 | 200,000 tokens | Extended context, reduced hallucinations |
| claude-2 | 100,000 tokens | Versatile model for various tasks |
| claude-instant | 100,000 tokens | Fast, cost-effective for everyday tasks |
See Anthropic's [models overview](https://platform.claude.com/docs/en/about-claude/models/overview)
for current model IDs and capabilities, and review the
[model deprecation table](https://platform.claude.com/docs/en/about-claude/model-deprecations)
before pinning a model in production.
**Note:** To use Anthropic, install the required dependencies:
```bash
@@ -495,9 +460,8 @@ In this section, you'll find detailed examples that help you select, configure,
from crewai import LLM
llm = LLM(
model="gemini/gemini-2.0-flash",
model="gemini/gemini-3.6-flash",
api_key="your-api-key", # Or set GOOGLE_API_KEY/GEMINI_API_KEY
temperature=0.7
)
```
@@ -506,11 +470,8 @@ In this section, you'll find detailed examples that help you select, configure,
from crewai import LLM
llm = LLM(
model="gemini/gemini-2.5-flash",
model="gemini/gemini-3.6-flash",
api_key="your-api-key",
temperature=0.7,
top_p=0.9,
top_k=40, # Top-k sampling parameter
max_output_tokens=8192,
stop_sequences=["END", "STOP"],
stream=True, # Enable streaming
@@ -536,8 +497,7 @@ In this section, you'll find detailed examples that help you select, configure,
from crewai import LLM
llm = LLM(
model="gemini/gemini-2.0-flash",
temperature=0.7
model="gemini/gemini-3.6-flash"
)
```
@@ -554,7 +514,7 @@ In this section, you'll find detailed examples that help you select, configure,
from crewai import LLM
llm = LLM(
model="gemini/gemini-1.5-pro",
model="gemini/gemini-3.6-flash",
project="your-gcp-project-id",
location="us-central1" # GCP region
)
@@ -567,7 +527,7 @@ In this section, you'll find detailed examples that help you select, configure,
- `GOOGLE_CLOUD_LOCATION`: GCP location (defaults to `us-central1`)
**Features:**
- Native function calling support for Gemini 1.5+ and 2.x models
- Native function calling support for compatible Gemini models
- Streaming support for real-time responses
- Multimodal capabilities (text, images, video)
- Safety settings configuration
@@ -575,53 +535,24 @@ In this section, you'll find detailed examples that help you select, configure,
- Automatic system instruction handling
- Token usage tracking
**Gemini Models:**
Google offers a range of powerful models optimized for different use cases.
| Model | Context Window | Best For |
|--------------------------------|----------------|-------------------------------------------------------------------|
| gemini-2.5-flash | 1M tokens | Adaptive thinking, cost efficiency |
| gemini-2.5-pro | 1M tokens | Enhanced thinking and reasoning, multimodal understanding |
| gemini-2.0-flash | 1M tokens | Next generation features, speed, thinking |
| gemini-2.0-flash-thinking | 32,768 tokens | Advanced reasoning with thinking process |
| gemini-2.0-flash-lite | 1M tokens | Cost efficiency and low latency |
| gemini-1.5-pro | 2M tokens | Best performing, logical reasoning, coding |
| gemini-1.5-flash | 1M tokens | Balanced multimodal model, good for most tasks |
| gemini-1.5-flash-8b | 1M tokens | Fastest, most cost-efficient |
| gemini-1.0-pro | 32,768 tokens | Earlier generation model |
**Gemma Models:**
The Gemini API also supports [Gemma models](https://ai.google.dev/gemma/docs) hosted on Google infrastructure.
| Model | Context Window | Best For |
|----------------|----------------|------------------------------------|
| gemma-3-1b | 32,000 tokens | Ultra-lightweight tasks |
| gemma-3-4b | 128,000 tokens | Efficient general-purpose tasks |
| gemma-3-12b | 128,000 tokens | Balanced performance and efficiency|
| gemma-3-27b | 128,000 tokens | High-performance tasks |
Google publishes current Gemini IDs, capabilities, and lifecycle stages in
the [Gemini model catalog](https://ai.google.dev/gemini-api/docs/models).
Check the [deprecation schedule](https://ai.google.dev/gemini-api/docs/deprecations)
before choosing a stable or preview model. The Gemini API also hosts
[Gemma models](https://ai.google.dev/gemma/docs).
**Note:** To use Google Gemini, install the required dependencies:
```bash
uv add "crewai[google-genai]"
```
The full list of models is available in the [Gemini model docs](https://ai.google.dev/gemini-api/docs/models).
</Accordion>
<Accordion title="Google (Vertex AI)">
Get credentials from your Google Cloud Console and save it to a JSON file, then load it with the following code:
```python Code
import json
file_path = 'path/to/vertex_ai_service_account.json'
# Load the JSON file
with open(file_path, 'r') as file:
vertex_credentials = json.load(file)
# Convert the credentials to a JSON string
vertex_credentials_json = json.dumps(vertex_credentials)
Authenticate with [Application Default Credentials](https://cloud.google.com/docs/authentication/provide-credentials-adc), then configure the native Gemini provider for Vertex AI:
```toml .env
GOOGLE_GENAI_USE_VERTEXAI=true
GOOGLE_CLOUD_PROJECT=<your-project-id>
GOOGLE_CLOUD_LOCATION=<location>
```
Example usage in your CrewAI project:
@@ -629,27 +560,17 @@ In this section, you'll find detailed examples that help you select, configure,
from crewai import LLM
llm = LLM(
model="gemini-1.5-pro-latest", # or vertex_ai/gemini-1.5-pro-latest
temperature=0.7,
vertex_credentials=vertex_credentials_json
model="gemini/gemini-3.6-flash"
)
```
Google offers a range of powerful models optimized for different use cases:
Vertex AI availability varies by region. Use the
[Vertex AI model catalog](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models)
to verify the model ID and location before deployment.
| Model | Context Window | Best For |
|--------------------------------|----------------|-------------------------------------------------------------------|
| gemini-2.5-flash-preview-04-17 | 1M tokens | Adaptive thinking, cost efficiency |
| gemini-2.5-pro-preview-05-06 | 1M tokens | Enhanced thinking and reasoning, multimodal understanding, advanced coding, and more |
| gemini-2.0-flash | 1M tokens | Next generation features, speed, thinking, and realtime streaming |
| gemini-2.0-flash-lite | 1M tokens | Cost efficiency and low latency |
| gemini-1.5-flash | 1M tokens | Balanced multimodal model, good for most tasks |
| gemini-1.5-flash-8B | 1M tokens | Fastest, most cost-efficient, good for high-frequency tasks |
| gemini-1.5-pro | 2M tokens | Best performing, wide variety of reasoning tasks including logical reasoning, coding, and creative collaboration |
**Note:** This provider uses LiteLLM. Add it as a dependency to your project:
**Note:** This route uses CrewAI's native Gemini integration. Add it as a dependency to your project:
```bash
uv add 'crewai[litellm]'
uv add "crewai[google-genai]"
```
</Accordion>
@@ -740,7 +661,7 @@ In this section, you'll find detailed examples that help you select, configure,
from crewai import LLM
llm = LLM(
model="bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
model="bedrock/us.anthropic.claude-sonnet-4-6",
region_name="us-east-1"
)
```
@@ -750,7 +671,7 @@ In this section, you'll find detailed examples that help you select, configure,
from crewai import LLM
llm = LLM(
model="bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
model="bedrock/us.anthropic.claude-sonnet-4-6",
aws_access_key_id="your-access-key", # Or set AWS_ACCESS_KEY_ID
aws_secret_access_key="your-secret-key", # Or set AWS_SECRET_ACCESS_KEY
aws_session_token="your-session-token", # For temporary credentials
@@ -795,38 +716,9 @@ In this section, you'll find detailed examples that help you select, configure,
- First message must be from user (automatically handled)
- Some models (like Cohere) require conversation to end with user message
[Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) is a managed service that provides access to multiple foundation models from top AI companies through a unified API.
| Model | Context Window | Best For |
|-------------------------|----------------------|-------------------------------------------------------------------|
| Amazon Nova Pro | Up to 300k tokens | High-performance, model balancing accuracy, speed, and cost-effectiveness across diverse tasks. |
| Amazon Nova Micro | Up to 128k tokens | High-performance, cost-effective text-only model optimized for lowest latency responses. |
| Amazon Nova Lite | Up to 300k tokens | High-performance, affordable multimodal processing for images, video, and text with real-time capabilities. |
| Claude 3.7 Sonnet | Up to 128k tokens | High-performance, best for complex reasoning, coding & AI agents |
| Claude 3.5 Sonnet v2 | Up to 200k tokens | State-of-the-art model specialized in software engineering, agentic capabilities, and computer interaction at optimized cost. |
| Claude 3.5 Sonnet | Up to 200k tokens | High-performance model delivering superior intelligence and reasoning across diverse tasks with optimal speed-cost balance. |
| Claude 3.5 Haiku | Up to 200k tokens | Fast, compact multimodal model optimized for quick responses and seamless human-like interactions |
| Claude 3 Sonnet | Up to 200k tokens | Multimodal model balancing intelligence and speed for high-volume deployments. |
| Claude 3 Haiku | Up to 200k tokens | Compact, high-speed multimodal model optimized for quick responses and natural conversational interactions |
| Claude 3 Opus | Up to 200k tokens | Most advanced multimodal model exceling at complex tasks with human-like reasoning and superior contextual understanding. |
| Claude 2.1 | Up to 200k tokens | Enhanced version with expanded context window, improved reliability, and reduced hallucinations for long-form and RAG applications |
| Claude | Up to 100k tokens | Versatile model excelling in sophisticated dialogue, creative content, and precise instruction following. |
| Claude Instant | Up to 100k tokens | Fast, cost-effective model for everyday tasks like dialogue, analysis, summarization, and document Q&A |
| Llama 3.1 405B Instruct | Up to 128k tokens | Advanced LLM for synthetic data generation, distillation, and inference for chatbots, coding, and domain-specific tasks. |
| Llama 3.1 70B Instruct | Up to 128k tokens | Powers complex conversations with superior contextual understanding, reasoning and text generation. |
| Llama 3.1 8B Instruct | Up to 128k tokens | Advanced state-of-the-art model with language understanding, superior reasoning, and text generation. |
| Llama 3 70B Instruct | Up to 8k tokens | Powers complex conversations with superior contextual understanding, reasoning and text generation. |
| Llama 3 8B Instruct | Up to 8k tokens | Advanced state-of-the-art LLM with language understanding, superior reasoning, and text generation. |
| Titan Text G1 - Lite | Up to 4k tokens | Lightweight, cost-effective model optimized for English tasks and fine-tuning with focus on summarization and content generation. |
| Titan Text G1 - Express | Up to 8k tokens | Versatile model for general language tasks, chat, and RAG applications with support for English and 100+ languages. |
| Cohere Command | Up to 4k tokens | Model specialized in following user commands and delivering practical enterprise solutions. |
| Jurassic-2 Mid | Up to 8,191 tokens | Cost-effective model balancing quality and affordability for diverse language tasks like Q&A, summarization, and content generation. |
| Jurassic-2 Ultra | Up to 8,191 tokens | Model for advanced text generation and comprehension, excelling in complex tasks like analysis and content creation. |
| Jamba-Instruct | Up to 256k tokens | Model with extended context window optimized for cost-effective text generation, summarization, and Q&A. |
| Mistral 7B Instruct | Up to 32k tokens | This LLM follows instructions, completes requests, and generates creative text. |
| Mistral 8x7B Instruct | Up to 32k tokens | An MOE LLM that follows instructions, completes requests, and generates creative text. |
| DeepSeek R1 | 32,768 tokens | Advanced reasoning model |
Amazon Bedrock model access and IDs vary by region. Use AWS's
[supported models and regions](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html)
reference to select a model and verify Converse API support.
**Note:** To use AWS Bedrock, install the required dependencies:
```bash
uv add "crewai[bedrock]"
@@ -882,81 +774,14 @@ In this section, you'll find detailed examples that help you select, configure,
Example usage in your CrewAI project:
```python Code
llm = LLM(
model="nvidia_nim/meta/llama3-70b-instruct",
model="nvidia_nim/nvidia/nvidia-nemotron-3-ultra-550b-a55b",
temperature=0.7
)
```
Nvidia NIM provides a comprehensive suite of models for various use cases, from general-purpose tasks to specialized applications.
| Model | Context Window | Best For |
|-------------------------------------------------------------------------|----------------|-------------------------------------------------------------------|
| nvidia/mistral-nemo-minitron-8b-8k-instruct | 8,192 tokens | State-of-the-art small language model delivering superior accuracy for chatbot, virtual assistants, and content generation. |
| nvidia/nemotron-4-mini-hindi-4b-instruct | 4,096 tokens | A bilingual Hindi-English SLM for on-device inference, tailored specifically for Hindi Language. |
| nvidia/llama-3.1-nemotron-70b-instruct | 128k tokens | Customized for enhanced helpfulness in responses |
| nvidia/llama3-chatqa-1.5-8b | 128k tokens | Advanced LLM to generate high-quality, context-aware responses for chatbots and search engines. |
| nvidia/llama3-chatqa-1.5-70b | 128k tokens | Advanced LLM to generate high-quality, context-aware responses for chatbots and search engines. |
| nvidia/vila | 128k tokens | Multi-modal vision-language model that understands text/img/video and creates informative responses |
| nvidia/neva-22 | 4,096 tokens | Multi-modal vision-language model that understands text/images and generates informative responses |
| nvidia/nemotron-mini-4b-instruct | 8,192 tokens | General-purpose tasks |
| nvidia/usdcode-llama3-70b-instruct | 128k tokens | State-of-the-art LLM that answers OpenUSD knowledge queries and generates USD-Python code. |
| nvidia/nemotron-4-340b-instruct | 4,096 tokens | Creates diverse synthetic data that mimics the characteristics of real-world data. |
| meta/codellama-70b | 100k tokens | LLM capable of generating code from natural language and vice versa. |
| meta/llama2-70b | 4,096 tokens | Cutting-edge large language AI model capable of generating text and code in response to prompts. |
| meta/llama3-8b-instruct | 8,192 tokens | Advanced state-of-the-art LLM with language understanding, superior reasoning, and text generation. |
| meta/llama3-70b-instruct | 8,192 tokens | Powers complex conversations with superior contextual understanding, reasoning and text generation. |
| meta/llama-3.1-8b-instruct | 128k tokens | Advanced state-of-the-art model with language understanding, superior reasoning, and text generation. |
| meta/llama-3.1-70b-instruct | 128k tokens | Powers complex conversations with superior contextual understanding, reasoning and text generation. |
| meta/llama-3.1-405b-instruct | 128k tokens | Advanced LLM for synthetic data generation, distillation, and inference for chatbots, coding, and domain-specific tasks. |
| meta/llama-3.2-1b-instruct | 128k tokens | Advanced state-of-the-art small language model with language understanding, superior reasoning, and text generation. |
| meta/llama-3.2-3b-instruct | 128k tokens | Advanced state-of-the-art small language model with language understanding, superior reasoning, and text generation. |
| meta/llama-3.2-11b-vision-instruct | 128k tokens | Advanced state-of-the-art small language model with language understanding, superior reasoning, and text generation. |
| meta/llama-3.2-90b-vision-instruct | 128k tokens | Advanced state-of-the-art small language model with language understanding, superior reasoning, and text generation. |
| google/gemma-7b | 8,192 tokens | Cutting-edge text generation model text understanding, transformation, and code generation. |
| google/gemma-2b | 8,192 tokens | Cutting-edge text generation model text understanding, transformation, and code generation. |
| google/codegemma-7b | 8,192 tokens | Cutting-edge model built on Google's Gemma-7B specialized for code generation and code completion. |
| google/codegemma-1.1-7b | 8,192 tokens | Advanced programming model for code generation, completion, reasoning, and instruction following. |
| google/recurrentgemma-2b | 8,192 tokens | Novel recurrent architecture based language model for faster inference when generating long sequences. |
| google/gemma-2-9b-it | 8,192 tokens | Cutting-edge text generation model text understanding, transformation, and code generation. |
| google/gemma-2-27b-it | 8,192 tokens | Cutting-edge text generation model text understanding, transformation, and code generation. |
| google/gemma-2-2b-it | 8,192 tokens | Cutting-edge text generation model text understanding, transformation, and code generation. |
| google/deplot | 512 tokens | One-shot visual language understanding model that translates images of plots into tables. |
| google/paligemma | 8,192 tokens | Vision language model adept at comprehending text and visual inputs to produce informative responses. |
| mistralai/mistral-7b-instruct-v0.2 | 32k tokens | This LLM follows instructions, completes requests, and generates creative text. |
| mistralai/mixtral-8x7b-instruct-v0.1 | 8,192 tokens | An MOE LLM that follows instructions, completes requests, and generates creative text. |
| mistralai/mistral-large | 4,096 tokens | Creates diverse synthetic data that mimics the characteristics of real-world data. |
| mistralai/mixtral-8x22b-instruct-v0.1 | 8,192 tokens | Creates diverse synthetic data that mimics the characteristics of real-world data. |
| mistralai/mistral-7b-instruct-v0.3 | 32k tokens | This LLM follows instructions, completes requests, and generates creative text. |
| nv-mistralai/mistral-nemo-12b-instruct | 128k tokens | Most advanced language model for reasoning, code, multilingual tasks; runs on a single GPU. |
| mistralai/mamba-codestral-7b-v0.1 | 256k tokens | Model for writing and interacting with code across a wide range of programming languages and tasks. |
| microsoft/phi-3-mini-128k-instruct | 128K tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
| microsoft/phi-3-mini-4k-instruct | 4,096 tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
| microsoft/phi-3-small-8k-instruct | 8,192 tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
| microsoft/phi-3-small-128k-instruct | 128K tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
| microsoft/phi-3-medium-4k-instruct | 4,096 tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
| microsoft/phi-3-medium-128k-instruct | 128K tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
| microsoft/phi-3.5-mini-instruct | 128K tokens | Lightweight multilingual LLM powering AI applications in latency bound, memory/compute constrained environments |
| microsoft/phi-3.5-moe-instruct | 128K tokens | Advanced LLM based on Mixture of Experts architecture to deliver compute efficient content generation |
| microsoft/kosmos-2 | 1,024 tokens | Groundbreaking multimodal model designed to understand and reason about visual elements in images. |
| microsoft/phi-3-vision-128k-instruct | 128k tokens | Cutting-edge open multimodal model exceling in high-quality reasoning from images. |
| microsoft/phi-3.5-vision-instruct | 128k tokens | Cutting-edge open multimodal model exceling in high-quality reasoning from images. |
| databricks/dbrx-instruct | 12k tokens | A general-purpose LLM with state-of-the-art performance in language understanding, coding, and RAG. |
| snowflake/arctic | 1,024 tokens | Delivers high efficiency inference for enterprise applications focused on SQL generation and coding. |
| aisingapore/sea-lion-7b-instruct | 4,096 tokens | LLM to represent and serve the linguistic and cultural diversity of Southeast Asia |
| ibm/granite-8b-code-instruct | 4,096 tokens | Software programming LLM for code generation, completion, explanation, and multi-turn conversion. |
| ibm/granite-34b-code-instruct | 8,192 tokens | Software programming LLM for code generation, completion, explanation, and multi-turn conversion. |
| ibm/granite-3.0-8b-instruct | 4,096 tokens | Advanced Small Language Model supporting RAG, summarization, classification, code, and agentic AI |
| ibm/granite-3.0-3b-a800m-instruct | 4,096 tokens | Highly efficient Mixture of Experts model for RAG, summarization, entity extraction, and classification |
| mediatek/breeze-7b-instruct | 4,096 tokens | Creates diverse synthetic data that mimics the characteristics of real-world data. |
| upstage/solar-10.7b-instruct | 4,096 tokens | Excels in NLP tasks, particularly in instruction-following, reasoning, and mathematics. |
| writer/palmyra-med-70b-32k | 32k tokens | Leading LLM for accurate, contextually relevant responses in the medical domain. |
| writer/palmyra-med-70b | 32k tokens | Leading LLM for accurate, contextually relevant responses in the medical domain. |
| writer/palmyra-fin-70b-32k | 32k tokens | Specialized LLM for financial analysis, reporting, and data processing |
| 01-ai/yi-large | 32k tokens | Powerful model trained on English and Chinese for diverse tasks including chatbot and creative writing. |
| deepseek-ai/deepseek-coder-6.7b-instruct | 2k tokens | Powerful coding model offering advanced capabilities in code generation, completion, and infilling |
| rakuten/rakutenai-7b-instruct | 1,024 tokens | Advanced state-of-the-art LLM with language understanding, superior reasoning, and text generation. |
| rakuten/rakutenai-7b-chat | 1,024 tokens | Advanced state-of-the-art LLM with language understanding, superior reasoning, and text generation. |
| baichuan-inc/baichuan2-13b-chat | 4,096 tokens | Support Chinese and English chat, coding, math, instruction following, solving quizzes |
NVIDIA NIM's hosted catalog changes frequently. Use the
[NVIDIA NIM model catalog](https://build.nvidia.com/models) to select a
current endpoint and verify its model ID, modalities, and context limits.
**Note:** This provider uses LiteLLM. Add it as a dependency to your project:
```bash
@@ -1074,15 +899,15 @@ In this section, you'll find detailed examples that help you select, configure,
Example usage in your CrewAI project:
```python Code
llm = LLM(
model="groq/llama-3.2-90b-text-preview",
model="groq/qwen/qwen3.6-27b",
temperature=0.7
)
```
| Model | Context Window | Best For |
|-------------------|------------------|--------------------------------------------|
| Llama 3.1 70B/8B | 131,072 tokens | High-performance, large context tasks |
| Llama 3.2 Series | 8,192 tokens | General-purpose tasks |
| Mixtral 8x7B | 32,768 tokens | Balanced performance and context |
Groq distinguishes production and preview models and retires model IDs
regularly. Check the [Groq model catalog](https://console.groq.com/docs/models)
and [deprecation page](https://console.groq.com/docs/deprecations) before
selecting a model for production.
**Note:** This provider uses LiteLLM. Add it as a dependency to your project:
```bash
@@ -1164,11 +989,14 @@ In this section, you'll find detailed examples that help you select, configure,
Example usage in your CrewAI project:
```python Code
llm = LLM(
model="llama-3.1-sonar-large-128k-online",
base_url="https://api.perplexity.ai/"
model="perplexity/sonar-pro"
)
```
See the [Perplexity model catalog](https://docs.perplexity.ai/getting-started/models)
and [changelog](https://docs.perplexity.ai/docs/resources/changelog) for
current model IDs and deprecation notices.
**Note:** This provider uses LiteLLM. Add it as a dependency to your project:
```bash
uv add 'crewai[litellm]'
@@ -1204,17 +1032,14 @@ In this section, you'll find detailed examples that help you select, configure,
Example usage in your CrewAI project:
```python Code
llm = LLM(
model="sambanova/Meta-Llama-3.1-8B-Instruct",
model="sambanova/Meta-Llama-3.3-70B-Instruct",
temperature=0.7
)
```
| Model | Context Window | Best For |
|--------------------|------------------------|----------------------------------------------|
| Llama 3.1 70B/8B | Up to 131,072 tokens | High-performance, large context tasks |
| Llama 3.1 405B | 8,192 tokens | High-performance and output quality |
| Llama 3.2 Series | 8,192 tokens | General-purpose, multimodal tasks |
| Llama 3.3 70B | Up to 131,072 tokens | High-performance and output quality |
| Qwen2 familly | 8,192 tokens | High-performance and output quality |
SambaNova Cloud's hosted models can change independently of CrewAI. Query
the [models endpoint](https://docs.sambanova.ai/docs/api-reference/models/get-environments-available-model-list-metadata)
and check the [deprecation guide](https://docs.sambanova.ai/docs/en/models/deprecations)
before deployment.
**Note:** This provider uses LiteLLM. Add it as a dependency to your project:
```bash
@@ -1232,7 +1057,7 @@ In this section, you'll find detailed examples that help you select, configure,
Example usage in your CrewAI project:
```python Code
llm = LLM(
model="cerebras/llama3.1-70b",
model="cerebras/gpt-oss-120b",
temperature=0.7,
max_tokens=8192
)
@@ -1246,6 +1071,10 @@ In this section, you'll find detailed examples that help you select, configure,
- Support for long context windows
</Info>
See the [Cerebras model catalog](https://inference-docs.cerebras.ai/models/overview)
and [deprecation notices](https://inference-docs.cerebras.ai/support/deprecation)
for current public endpoint IDs.
**Note:** This provider uses LiteLLM. Add it as a dependency to your project:
```bash
uv add 'crewai[litellm]'
@@ -1320,7 +1149,7 @@ CrewAI supports streaming responses from LLMs, allowing your application to rece
# Create an LLM with streaming enabled
llm = LLM(
model="openai/gpt-4o",
model="openai/gpt-5.6-terra",
stream=True # Enable streaming
)
```
@@ -1370,7 +1199,7 @@ CrewAI supports streaming responses from LLMs, allowing your application to rece
my_listener = MyCustomListener()
llm = LLM(model="gpt-4o-mini", temperature=0, stream=True)
llm = LLM(model="openai/gpt-5.6-terra", stream=True)
researcher = Agent(
role="About User",
@@ -1450,6 +1279,8 @@ CrewAI supports asynchronous LLM calls for improved performance and concurrency
CrewAI supports structured responses from LLM calls by allowing you to define a `response_format` using a Pydantic model. This enables the framework to automatically parse and validate the output, making it easier to integrate the response into your application without manual post-processing.
Structured output support varies by provider and model. Test your chosen model before relying on structured responses in production.
For example, you can define a Pydantic model to represent the expected response structure and pass it as the `response_format` when instantiating the LLM. The model will then be used to convert the LLM output into a structured Python object.
```python Code
@@ -1461,7 +1292,7 @@ class Dog(BaseModel):
breed: str
llm = LLM(model="gpt-4o", response_format=Dog)
llm = LLM(model="openai/gpt-5.6-terra", response_format=Dog)
response = llm.call(
"Analyze the following messages and return the name, age, and breed. "
@@ -1490,8 +1321,8 @@ Learn how to get the most out of your LLM configuration:
# 3. Task splitting for large contexts
llm = LLM(
model="gpt-4",
max_tokens=4000, # Limit response length
model="openai/gpt-5.6-terra",
max_completion_tokens=4000, # Limit response length
)
```
@@ -1515,15 +1346,16 @@ Learn how to get the most out of your LLM configuration:
```python
# Configure model with appropriate settings
llm = LLM(
model="openai/gpt-4-turbo-preview",
temperature=0.7, # Adjust based on task
max_tokens=4096, # Set based on output needs
timeout=300 # Longer timeout for complex tasks
model="openai/gpt-5.6-terra",
reasoning_effort="medium",
max_completion_tokens=4096,
timeout=300
)
```
<Tip>
- Lower temperature (0.1 to 0.3) for factual responses
- Higher temperature (0.7 to 0.9) for creative tasks
Use the controls supported by your selected model. Depending on the
provider, this may be `temperature`, a reasoning or thinking level,
or prompt instructions that define the desired style and variability.
</Tip>
</Step>

View File

@@ -9,7 +9,10 @@ mode: "wide"
Skills are self-contained directories that provide agents with **domain-specific instructions, guidelines, and reference material**. Each skill is defined by a `SKILL.md` file with YAML frontmatter and a markdown body.
When activated, a skill's instructions are injected directly into the agent's task prompt — giving the agent expertise without requiring any code changes.
Agents first receive each configured skill's name and description. When a
description applies to the current request, the agent loads that skill's full
instructions for that execution. This keeps unrelated instructions out of the
context while giving the agent the relevant expertise without code changes.
<Note type="info" title="Skills vs Tools — The Key Distinction">
**Skills are NOT tools.** This is the most common point of confusion.
@@ -79,12 +82,13 @@ reviewer = Agent(
role="Senior Code Reviewer",
goal="Review pull requests for quality and security issues",
backstory="Staff engineer with expertise in secure coding practices.",
skills=["./skills"], # Injects review guidelines
skills=["./skills"], # Discovers review skills
tools=[GithubSearchTool(), FileReadTool()], # Lets agent read code
)
```
The agent now has both **expertise** (from the skill) and **capabilities** (from the tools).
The agent now has both **expertise** (loaded from the relevant skill when
needed) and **capabilities** (from the tools).
---
@@ -221,6 +225,34 @@ agent = Agent(
)
```
### Pin a Version
An unpinned reference resolves to the newest published version, so publishing a
new version changes every agent that references it. Append `@<version>` to pin
one instead:
```python
agent = Agent(
role="Senior Code Reviewer",
goal="Review pull requests for quality and security issues",
backstory="Staff engineer with expertise in secure coding practices.",
skills=["@acme/code-review@1.2.0"], # pinned; a leading "v" also works
)
```
A pinned reference re-downloads unless the copy it finds is that exact version —
a pin asks for a specific version rather than hinting at one. A cached skill is
matched on the version recorded when it was installed, so it needs nothing in
its frontmatter; a project-local copy under `skills/` has no such record, so it
is matched on `metadata.version` in its `SKILL.md` frontmatter. Pinning an
unpublished version fails rather than falling back to the latest.
<Note>
Agents from the **Agent Repository** are pinned automatically: the repository
records a version alongside each skill it assigns, and the runtime applies those
pins when it loads the agent.
</Note>
### List
```shell Terminal
@@ -296,7 +328,8 @@ The directory name must match the `name` field in `SKILL.md`. The `scripts/`, `r
## Pre-loading Skills
For more control, you can discover and activate skills programmatically:
For more control, you can discover and activate skills programmatically.
Passing an activated skill makes its instructions always-on:
```python
from pathlib import Path
@@ -323,12 +356,21 @@ agent = Agent(
Skills use **progressive disclosure** — only loading what's needed at each stage:
| Stage | What's loaded | When |
| :--------- | :------------------------------------ | :------------------ |
| Discovery | Name, description, frontmatter fields | `discover_skills()` |
| Activation | Full SKILL.md body text | `activate_skill()` |
| Stage | What's loaded | When |
| :--------- | :------------------------------------ | :---------------------------------------- |
| Discovery | Name, description, frontmatter fields | Agent setup or `discover_skills()` |
| Activation | Full SKILL.md body text | Relevant runtime request or `activate_skill()` |
| Resources | Resource directory catalog | Explicit `load_resources()` call |
During normal agent execution (passing directory paths via `skills=["./skills"]`), skills are automatically discovered and activated. The progressive loading only matters when using the programmatic API.
With `skills=["./skills"]`, the directory is discovered at setup but the full
instructions are not placed in every prompt. The agent reviews the metadata on
each execution and loads only a skill that applies. The loaded instructions are
scoped to that execution, so skills selected for earlier calls do not accumulate
on the agent.
Inline skill strings and `Skill` objects already activated with
`activate_skill()` remain always-on. This provides an explicit opt-in when the
instructions should apply to every request.
---

View File

@@ -334,6 +334,126 @@ writer1 = Agent(
#...
```
## Reporting Tool Failures
A tool can finish without raising and still fail to do what it was asked. Slack
answers `HTTP 200` with `{"ok": false, "error": "channel_not_found"}`; an MCP
server sets `isError`; a platform action returns an error payload. The tool call
"worked", so the error text reaches the agent as an ordinary result — the agent
narrates the problem in its final answer and the run is recorded as a success.
Return a `ToolFailure` instead of an error string and the framework can tell the
difference:
```python Code
from typing import Any
from crewai.tools import BaseTool
from crewai.tools.tool_failure import ToolFailure
class SendSlackMessage(BaseTool):
name: str = "send_slack_message"
description: str = "Post a message to a Slack channel."
def _run(self, channel: str, text: str) -> Any:
payload = slack.post(channel=channel, text=text)
if not payload["ok"]:
return ToolFailure(
message=f"Slack rejected the message: {payload['error']}",
code=payload["error"],
retryable=payload["error"] == "rate_limited",
)
return payload
```
The agent still reads plain prose — `ToolFailure.as_agent_message()` renders the
message — so model behavior is unchanged. What changes is that the failure is now
visible to everything downstream.
Detection is strictly declarative. CrewAI never guesses whether a string "looks
like" an error, so a tool that legitimately returns text about an error is never
misread as having failed. Failures are recorded when a tool returns a
`ToolFailure`, when a tool raises, when an MCP server sets `isError`, when a
tool's `max_usage_count` is spent, or when the agent calls a tool that does not exist.
### Choosing a Failure Policy
`tool_failure_policy` controls what happens next:
| Policy | Behavior |
| :-- | :-- |
| `ignore` | Nothing is recorded, emitted, or acted on. |
| `warn` *(default)* | Records the failure, emits `ToolFailureDetectedEvent`, and continues. |
| `raise` | Records and emits, then aborts with `ToolExecutionFailedError`. |
```python Code
from crewai import Agent, Crew, Task
from crewai.tools.tool_failure import ToolFailurePolicy
agent = Agent(
role="Slack Messenger",
goal="Post the report to Slack",
backstory="...",
tools=[SendSlackMessage()],
tool_failure_policy=ToolFailurePolicy.WARN,
)
# Tighten a single high-stakes task without changing the agent.
task = Task(
description="Post the final report to #engineering",
expected_output="Confirmation the message was posted",
agent=agent,
tool_failure_policy=ToolFailurePolicy.RAISE,
)
# Or set a baseline once for every agent in the crew.
crew = Crew(
agents=[agent],
tasks=[task],
tool_failure_policy=ToolFailurePolicy.WARN,
)
```
The most specific setting wins: **tool → task → agent → crew → `warn`**. Every
level defaults to `None`, meaning "inherit from the next one out", so the
effective default with nothing configured anywhere is `warn`.
### Inspecting Failures
Recorded failures are structured, so nothing downstream has to parse a string:
```python Code
result = crew.kickoff()
if result.has_tool_failures:
for record in result.tool_failures:
print(record.tool_name) # "send_slack_message"
print(record.failure.code) # "channel_not_found"
print(record.failure.reason) # ToolFailureReason.TOOL_REPORTED
print(record.summary())
```
`tool_failures` is available on `TaskOutput`, `CrewOutput`, and
`LiteAgentOutput`. A crew can finish successfully with a non-empty list — check
it before treating `raw` as complete.
To react as failures happen, subscribe to the event:
```python Code
from crewai.events import ToolFailureDetectedEvent
from crewai.events.event_bus import crewai_event_bus
@crewai_event_bus.on(ToolFailureDetectedEvent)
def on_tool_failure(source, event):
print(f"{event.tool_name} failed: {event.failure.message} ({event.policy})")
```
The event is emitted before the `raise` policy aborts, so subscribers always
observe the failure. `ToolUsageFinishedEvent` also carries a `failure` field, letting
a trace UI mark the call as failed without correlating two events.
## Conclusion
Tools are pivotal in extending the capabilities of CrewAI agents, enabling them to undertake a broad spectrum of tasks and collaborate effectively.

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -22,6 +22,10 @@ These tools enable your agents to automate workflows, integrate with external pl
Automate browser interactions and web-based workflows.
</Card>
<Card title="Wait Tool" icon="hourglass-half" href="/edge/en/tools/automation/waittool">
Pause before re-checking a long-running job such as a build or deployment.
</Card>
<Card title="Zapier Actions Adapter" icon="bolt" href="/en/tools/automation/zapieractionstool">
Expose Zapier Actions as CrewAI tools for automation across thousands of apps.
</Card>

View File

@@ -0,0 +1,124 @@
---
title: Wait Tool
description: The `WaitTool` lets an agent pause before checking a long-running job again.
icon: hourglass-half
mode: "wide"
---
## Overview
The `WaitTool` pauses execution for a given number of seconds. It exists because agents that
kick off long-running work — a sandbox build, a deployment, a batch import, an async API job —
otherwise have no way to let time pass. Without it, an agent either polls in a tight loop or
gives up before the work finishes.
The tool takes no API key and has no dependencies beyond the standard library.
## When to Use It
The tool's description tells the model to reach for it when out-of-band work needs real time
to progress:
- A sandbox build, test run, or script that is still executing
- A deployment or provisioning step that is still rolling out
- A batch import, export, or training job
- An async API that returned a job id to poll later
- A rate limit or backoff that has to cool down before retrying
The pattern the model is steered toward is: start the job, wait, check status, wait again if it
is still running. The description also tells it *not* to wait to pace a conversation or when the
information it needs is already available — waiting only lets clock time pass, it does not
advance or check the job.
## Installation
The tool ships with `crewai-tools`:
```shell
uv add crewai-tools
```
## Example
```python Code
from crewai import Agent, Crew, Task
from crewai.tools import tool
from crewai_tools import WaitTool
wait_tool = WaitTool()
@tool("Check build status")
def check_build_status_tool(build_id: str) -> str:
"""Return the current status of a build: queued, running, passed, or failed."""
# Replace this with a call to your own build system.
return my_ci_client.get_build(build_id).status
build_agent = Agent(
role="Build Monitor",
goal="Start the build and report its final status",
backstory="An engineer who knows that builds take time.",
tools=[wait_tool, check_build_status_tool],
verbose=True,
)
monitor_task = Task(
description=(
"Start the build, then wait and re-check its status until it finishes."
),
expected_output="The final build status.",
agent=build_agent,
)
crew = Crew(agents=[build_agent], tasks=[monitor_task])
result = crew.kickoff()
```
## Arguments
| Argument | Type | Required | Description |
| :-------- | :------ | :------- | :----------------------------------------------------------------------------- |
| `seconds` | `float` | ✅ | How many seconds to wait. Must be zero or greater. |
| `reason` | `str` | ❌ | Optional note on what is being waited for. Echoed back in the tool's result. |
## Initialization Parameters
| Parameter | Type | Default | Description |
| :------------ | :------ | :------ | :----------------------------------------------------------------------------------- |
| `max_seconds` | `float` | `300` | Upper bound for a single wait. Longer requests are capped to this value, not rejected. |
## Capping Long Waits
A single call waits at most `max_seconds`. If an agent asks for more, the tool waits the
maximum and says so in its result, so the agent can call it again rather than fail:
```python Code
wait_tool = WaitTool()
wait_tool.run(seconds=3600)
# 'Waited 300 seconds. Requested 3600 seconds, capped at 300 seconds per call -
# call this tool again if more waiting is needed.'
```
Raise the cap when a workflow genuinely needs longer single pauses:
```python Code
wait_tool = WaitTool(max_seconds=1800)
```
## Async Support
The tool implements both sync and async execution, so it does not block the event loop when
awaited:
```python Code
import asyncio
async def main():
result = await wait_tool.arun(seconds=30, reason="waiting for the sandbox build")
print(result)
asyncio.run(main())
```

View File

@@ -29,6 +29,10 @@ If you route untrusted input to agents using this tool, treat it as a high-risk
## Hardening Recommendations
<Warning>
The built-in read-only checks are defence in depth, not a complete boundary. They inspect the statement text, and SQL is dialect-specific: a statement beginning with `SELECT` can still reach the database server's filesystem (`SELECT ... INTO OUTFILE`, `pg_read_file()`) or call a side-effecting function. The known sinks are blocked explicitly, but the only complete control is the privileges you grant in `db_uri`. **Point the tool at a least-privileged, read-only database role.**
</Warning>
Use all of the following in production:
- Use a read-only database user whenever possible
@@ -49,7 +53,21 @@ Use all of the following in production:
Any attempt to execute a write operation (`INSERT`, `UPDATE`, `DELETE`, `DROP`, `CREATE`, `ALTER`, `TRUNCATE`, etc.) will raise an error unless DML is explicitly enabled.
Multi-statement queries containing semicolons (e.g. `SELECT 1; DROP TABLE users`) are also blocked in read-only mode to prevent injection attacks.
Read-only mode also blocks the indirect routes to a write:
| Blocked in read-only mode | Example |
| --- | --- |
| Multi-statement queries | `SELECT 1; DROP TABLE users` |
| Writable CTEs, including the materialised spelling | `WITH d AS MATERIALIZED (DELETE FROM users RETURNING *) SELECT * FROM d` |
| A write following a CTE | `WITH d AS (SELECT 1) DELETE FROM users` |
| `EXPLAIN ANALYZE`, which executes its argument | `EXPLAIN ANALYZE DELETE FROM users` |
| Writes to the database server's filesystem | `SELECT * FROM users INTO OUTFILE '/var/www/shell.php'` |
| Functions reaching the server's filesystem or opening a new connection | `SELECT pg_read_file('/etc/passwd')`, `dblink_exec(...)` |
| A `WITH` statement that cannot be parsed as read-only | `WITH d AS DELETE FROM users` |
Statements are analysed with string literals and comments masked out, so a keyword hidden in a literal is not mistaken for a command (`SELECT 'DROP TABLE users'` is allowed) and a comment placed between keywords does not hide one (`EXPLAIN /*x*/ ANALYZE DELETE ...` is blocked). A semicolon inside a string literal does not count as a statement separator, so `SELECT ';'` is a single valid statement.
In read-only mode the tool additionally marks the transaction `SET TRANSACTION READ ONLY`, so PostgreSQL and MySQL reject writes at the database regardless of how the statement was spelled. Backends without that syntax (SQLite, SQL Server, Snowflake) log a debug message and fall back to statement validation alone — one more reason to rely on a read-only role rather than on parsing.
### Enabling Write Operations

View File

@@ -11,10 +11,12 @@ mode: "wide"
We are still working on improving tools, so there might be unexpected behavior or changes in the future.
</Note>
The FileReadTool conceptually represents a suite of functionalities within the crewai_tools package aimed at facilitating file reading and content retrieval.
This suite includes tools for processing batch text files, reading runtime configuration files, and importing data for analytics.
It supports a variety of text-based file formats such as `.txt`, `.csv`, `.json`, and more. Depending on the file type, the suite offers specialized functionality,
such as converting JSON content into a Python dictionary for ease of use.
The `FileReadTool` reads the contents of a file from the local file system and returns it as text.
It is useful for batch text file processing, reading runtime configuration files, and importing data for analytics.
It supports any text-based file format, such as `.txt`, `.csv`, `.json`, and `.md`.
Content is always returned as plain text — parsing it (for example, `json.loads` on a `.json` file) is up to the agent or your own code.
For large files, `start_line` and `line_count` read just a window of lines instead of loading the whole file.
## Installation
@@ -31,15 +33,48 @@ To get started with the FileReadTool:
```python Code
from crewai_tools import FileReadTool
# Initialize the tool to read any files the agents knows or lean the path for
# Initialize the tool to read any file the agent knows or learns the path for
file_read_tool = FileReadTool()
# OR
# Initialize the tool with a specific file path, so the agent can only read the content of the specified file
# Initialize with a specific file path, so the agent reads that file by default
file_read_tool = FileReadTool(file_path='path/to/your/file.txt')
# Read a window of lines (lines 100-149) instead of the whole file
partial_content = file_read_tool.run(
file_path='path/to/your/file.txt',
start_line=100,
line_count=50,
)
```
## Arguments
- `file_path`: The path to the file you want to read. It accepts both absolute and relative paths. Ensure the file exists and you have the necessary permissions to access it.
The agent supplies these at runtime:
- `file_path`: (Optional) The path to the file you want to read. Accepts absolute and relative paths. Ensure the file exists and you have the necessary permissions to access it. Omit it to read the default file configured at construction; if there is no default, the tool reports that no path was provided.
- `start_line`: (Optional) The line number to start reading from (1-indexed). Defaults to `1`.
- `line_count`: (Optional) The number of lines to read. If omitted, reads from `start_line` to the end of the file.
You set these when constructing the tool:
- `file_path`: (Optional) A default file to read when the agent calls the tool with no arguments.
- `base_dir`: (Optional) The directory that runtime paths must stay inside. Defaults to the current working directory.
- `encoding`: (Optional) Text encoding used to decode the file. Defaults to `utf-8`.
## Allowed paths
Because the file path is usually chosen by an LLM at runtime, reads are confined to a sandbox:
- Paths supplied at runtime must resolve inside `base_dir`, which defaults to the current working directory. `..` segments and symlinks are resolved before the check, so they cannot be used to escape.
- A `file_path` passed to the constructor is developer-declared intent, so it is always allowed past the containment check — even outside `base_dir`. The read itself can still fail if the file is missing, is a directory, or is not permitted. It is pinned when the tool is built, so a later change of working directory cannot repoint it, and the agent can address it either by omitting `file_path` or by using the name shown in the tool's description. Declaring one file does not expose its siblings.
To let an agent read a directory tree outside the working directory, point `base_dir` at it:
```python Code
# The agent may read anything under /data, and nothing outside it
file_read_tool = FileReadTool(base_dir='/data')
```
As a last resort, setting `CREWAI_TOOLS_ALLOW_UNSAFE_PATHS=true` disables path validation. This applies process-wide to every crewai-tools tool, including the SSRF protections on URL-fetching tools, so prefer `base_dir`.

View File

@@ -11,7 +11,7 @@ mode: "wide"
The `FileWriterTool` is a component of the crewai_tools package, designed to simplify the process of writing content to files with cross-platform compatibility (Windows, Linux, macOS).
It is particularly useful in scenarios such as generating reports, saving logs, creating configuration files, and more.
This tool handles path differences across operating systems, supports UTF-8 encoding, and automatically creates directories if they don't exist, making it easier to organize your output reliably across different platforms.
This tool handles path differences across operating systems, writes UTF-8 by default rather than the platform's locale encoding, and automatically creates directories if they don't exist, making it easier to organize your output reliably across different platforms.
## Installation
@@ -32,15 +32,45 @@ from crewai_tools import FileWriterTool
file_writer_tool = FileWriterTool()
# Write content to a file in a specified directory
result = file_writer_tool._run('example.txt', 'This is a test content.', 'test_directory')
result = file_writer_tool.run(
filename='example.txt',
content='This is a test content.',
directory='test_directory',
)
print(result)
```
## Arguments
- `filename`: The name of the file you want to create or overwrite.
- `content`: The content to write into the file.
- `directory` (optional): The path to the directory where the file will be created. Defaults to the current directory (`.`). If the directory does not exist, it will be created.
The agent supplies these at runtime:
- `filename`: The name of the file to write, relative to `directory`. May include subdirectories, which are created if they don't exist.
- `content`: The text content to write into the file.
- `directory` (optional): The path to the directory where the file will be created. A relative path resolves inside the tool's allowed directory — `base_dir` when set, the current working directory otherwise — and defaults to its root. If the directory does not exist, it will be created.
- `overwrite` (optional): Whether to replace the file when it already exists. Accepts `true`/`false` (also `yes`/`no`, `on`/`off`, `1`/`0`). Defaults to `false`, which reports an error instead of replacing existing content.
You set these when constructing the tool:
- `base_dir` (optional): The directory that writes must stay inside. Defaults to the current working directory.
- `encoding` (optional): Text encoding used to write the file. Defaults to `utf-8`.
## Allowed paths
Because both the directory and the filename are usually chosen by an LLM at runtime, writes are confined to a sandbox:
- The resolved `directory` must be inside `base_dir`, which defaults to the current working directory.
- The resolved file must then be inside that `directory`. `..` segments, absolute paths, and symlinks are resolved before both checks, so they cannot be used to escape.
To let an agent write outside the working directory, point `base_dir` at the target tree:
```python Code
# The agent may write anywhere under /var/output, and nowhere outside it
file_writer_tool = FileWriterTool(base_dir='/var/output')
```
<Note>
Previously an absolute `directory` could write anywhere the process had permission to. If you relied on that, set `base_dir` to the tree you want to allow. Setting `CREWAI_TOOLS_ALLOW_UNSAFE_PATHS=true` restores the old behavior, but it applies process-wide to every crewai-tools tool, including the SSRF protections on URL-fetching tools, so prefer `base_dir`.
</Note>
## Conclusion

View File

@@ -4,6 +4,125 @@ description: "CrewAI의 제품 업데이트, 개선 사항 및 버그 수정"
icon: "clock"
mode: "wide"
---
<Update label="2026년 7월 29일">
## v1.15.9
[GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.15.9)
## 변경 사항
### 기능
- 성공으로 보고하는 대신 도구 실패를 표면화
- 흐름 실행이 실패할 때 FlowFailedEvent 발생
- 기술에 대한 점진적 공개 구현
### 문서
- v1.15.8에 대한 스냅샷 및 변경 로그 업데이트
## 기여자
@github-actions[bot], @joaomdmoura, @lorenzejay, @lucasgomide
</Update>
<Update label="2026년 7월 28일">
## v1.15.8
[GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.15.8)
## 변경 사항
### 기능
- 장시간 실행되는 작업에서 일시 중지를 위한 WaitTool 추가.
### 버그 수정
- FileWriterTool의 쓰기 기능 수정 및 파일 도구의 거친 부분 해결.
- E2B 도구에 대해 E2B_API_KEY를 필수 환경 변수로 표시.
### 문서
- 모델 가용성 안내 새로 고침.
## 기여자
@github-actions[bot], @joaomdmoura, @lucasgomide, @oalami, @thiagomoretto
</Update>
<Update label="2026년 7월 26일">
## v1.15.7
[GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.15.7)
## 변경 사항
### 버그 수정
- 런타임의 CrewAI+ 클라이언트를 통해 레지스트리 기술 해결
- GPT-5.6 도구 + reasoning_effort 400에서 복구
- Responses API 경로에서 도구 호출 작동
- 404 오류 대신 응답 전용 모델 라우팅
- CVE-2026-16796 패치를 위해 bedrock-agentcore 버전 업그레이드
### 관찰 가능성
- 관찰 가능성을 위해 런타임에서 기술 사용 이벤트 발행
### 문서
- v1.15.7a1에 대한 스냅샷 및 변경 로그 추가
## 기여자
@alex-clawd, @joaomdmoura, @lorenzejay
</Update>
<Update label="2026년 7월 26일">
## v1.15.7a1
[GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.15.7a1)
## 변경 사항
### 버그 수정
- 런타임의 CrewAI+ 클라이언트를 통한 레지스트리 기술 해결 문제 수정.
- GPT-5.6 도구 및 reasoning_effort 400 오류에서 복구.
- Responses API 경로에서 도구 호출이 작동하도록 수정.
- 404 오류를 방지하기 위해 응답 전용 모델을 라우팅.
- CVE-2026-16796 패치를 위해 bedrock-agentcore 의존성 버전 증가.
### 관찰 가능성
- 향상된 관찰 가능성을 위해 런타임에서 기술 사용 이벤트 방출.
### 문서
- 버전 1.15.6에 대한 스냅샷 및 변경 로그 업데이트.
## 기여자
@alex-clawd, @joaomdmoura, @lorenzejay
</Update>
<Update label="2026년 7월 24일">
## v1.15.6
[GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.15.6)
## 변경 사항
### 버그 수정
- Anthropic 미리보기 도구 사용 차단 감지 수정.
- 엄격한 도구 스키마 속성 이름 유지.
- 실패한 크루 및 흐름 실행에서 execution_end 후크 전송.
- load_agent_from_repository에서 비동기 get_agent 처리.
- 의존성 해결 문제 수정.
### 문서
- v1.15.5에 대한 스냅샷 및 변경 로그.
## 기여자
@alex-clawd, @iris-clawd, @lorenzejay, @lucasgomide, @theCyberTech, @vinibrsl
</Update>
<Update label="2026년 7월 20일">
## v1.15.5

View File

@@ -255,6 +255,7 @@ CrewAI는 여러분이 청취할 수 있는 다양한 이벤트를 제공합니
- **FlowCreatedEvent**: Flow가 생성될 때 발생
- **FlowStartedEvent**: Flow가 실행을 시작할 때 발생
- **FlowFinishedEvent**: Flow가 실행을 완료할 때 발생
- **FlowFailedEvent**: Flow 실행이 실패할 때 발생합니다. Flow 이름과 실행을 종료시킨 예외를 포함합니다.
- **FlowPausedEvent**: 사람의 피드백을 기다리며 Flow가 일시 중지될 때 발생합니다. Flow 이름, Flow ID, 메서드 이름, 현재 상태, 피드백 요청 시 표시되는 메시지, 라우팅을 위한 선택적 결과 목록을 포함합니다.
- **FlowPlotEvent**: Flow가 플롯될 때 발생
- **MethodExecutionStartedEvent**: Flow 메서드가 실행을 시작할 때 발생

View File

@@ -21,7 +21,7 @@ Large Language Models(LLM)는 CrewAI 에이전트의 핵심 지능입니다. 에
컨텍스트 윈도우는 LLM이 한 번에 처리할 수 있는 텍스트 양을 결정합니다. 더 큰 윈도우(예: 128K 토큰)는 더 많은 문맥을 다룰 수 있지만, 비용과 속도 면에서 더 부담이 될 수 있습니다.
</Card>
<Card title="Temperature" icon="temperature-three-quarters">
Temperature(0.0에서 1.0)는 응답의 무작위성을 조절합니다. 낮은 값(예: 0.2)은 더 집중적이고 결정적인 결과를, 높은 값(예: 0.8)은 창의성과 다양성을 높입니다.
Temperature는 일부 모델이 지원하는 샘플링 제어 옵션입니다. 값이 낮을수록 일반적으로 샘플링이 더 집중되고, 값이 높을수록 변동성이 커집니다. 일부 최신 추론 모델은 이 파라미터를 무시하거나 더 이상 권장하지 않거나 거부하므로, 설정하기 전에 선택한 모델의 문서를 확인하세요.
</Card>
<Card title="제공자 선택" icon="server">
각 LLM 제공자(예: OpenAI, Anthropic, Google)는 다양한 기능, 가격, 특성을 가진 모델을 제공합니다. 정확성, 속도, 비용 등 요구 사항에 따라 선택하세요.
@@ -37,7 +37,7 @@ CrewAI 코드 내에는 사용할 모델을 지정할 수 있는 여러 위치
가장 간단하게 시작할 수 있는 방법입니다. `.env` 파일이나 앱 코드에서 환경 변수로 직접 모델을 설정할 수 있습니다. `crewai create`를 사용해 프로젝트를 부트스트랩했다면 이미 설정되어 있을 수 있습니다.
```bash .env
MODEL=model-id # e.g. gpt-4o, gemini-2.0-flash, claude-3-sonnet-...
MODEL=provider/model-id # e.g. openai/gpt-5.6-terra
# 반드시 여기에서 API 키도 설정하세요. 아래 제공자
# 섹션을 참고하세요.
@@ -56,7 +56,7 @@ CrewAI 코드 내에는 사용할 모델을 지정할 수 있는 여러 위치
goal: Conduct comprehensive research and analysis
backstory: A dedicated research professional with years of experience
verbose: true
llm: provider/model-id # e.g. openai/gpt-4o, google/gemini-2.0-flash, anthropic/claude...
llm: provider/model-id # e.g. anthropic/claude-sonnet-4-6
# (아래 제공자 구성 예제 참고)
```
@@ -75,32 +75,24 @@ CrewAI 코드 내에는 사용할 모델을 지정할 수 있는 여러 위치
from crewai import LLM
# 기본 설정
llm = LLM(model="model-id-here") # gpt-4o, gemini-2.0-flash, anthropic/claude...
llm = LLM(model="provider/model-id") # e.g. gemini/gemini-3.6-flash
# 자세한 파라미터로 고급 설정
llm = LLM(
model="model-id-here", # gpt-4o, gemini-2.0-flash, anthropic/claude...
temperature=0.7, # 더욱 창의적인 결과를 원할 때 높게 설정
timeout=120, # 응답을 기다릴 최대 초
max_tokens=4000, # 응답의 최대 길이
top_p=0.9, # 누클리어스 샘플링 파라미터
frequency_penalty=0.1 , # 반복 줄이기
presence_penalty=0.1, # 주제 다양성 높이기
model="provider/model-id",
timeout=120,
max_tokens=4000,
response_format={"type": "json"}, # 구조화된 출력용
seed=42 # 결과 재현성 확보용
)
```
<Info>
파라미터 설명:
- `temperature`: 랜덤성 제어 (0.0-1.0)
- `timeout`: 응답 대기 최대 시간
- `max_tokens`: 응답 길이 제한
- `top_p`: 샘플링 시 temperature의 대체값
- `frequency_penalty`: 단어 반복 감소
- `presence_penalty`: 새로운 주제 생성 유도
- `response_format`: 출력 구조 지정
- `seed`: 일관된 출력 보장
`temperature`, `top_p` 같은 샘플링 제어, 페널티 파라미터, 토큰 제한 파라미터 이름, 추론 제어는 모델별로 다릅니다. 선택한 제공자와 모델이 지원하는 경우에만 추가하세요. 아래 제공자 예시와 해당 제공자의 모델 문서를 참고하세요.
</Info>
</Tab>
</Tabs>
@@ -119,6 +111,10 @@ CrewAI 코드 내에는 사용할 모델을 지정할 수 있는 여러 위치
CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양한 LLM 공급자를 지원합니다.
이 섹션에서는 프로젝트의 요구에 가장 적합한 LLM을 선택, 구성, 최적화하는 데 도움이 되는 자세한 예시를 제공합니다.
<Warning>
모델 가용성은 자주 변경되며 계정, 리전, 클라우드 플랫폼에 따라 달라질 수 있습니다. 아래 예시는 작성 시점에 제공되는 모델을 사용하지만 전체 지원 목록은 아닙니다. 배포하기 전에 연결된 제공자 모델 카탈로그에서 모델 ID와 수명 주기 상태를 확인하세요.
</Warning>
<AccordionGroup>
<Accordion title="OpenAI">
`.env` 파일에 다음 환경 변수를 설정하십시오:
@@ -137,28 +133,13 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
from crewai import LLM
llm = LLM(
model="openai/gpt-4", # call model by provider/model_name
temperature=0.8,
max_tokens=150,
top_p=0.9,
frequency_penalty=0.1,
presence_penalty=0.1,
stop=["END"],
seed=42
model="openai/gpt-5.6-terra",
reasoning_effort="medium",
max_completion_tokens=4000
)
```
OpenAI는 다양한 모델과 기능을 제공하는 대표적인 LLM 공급자 중 하나입니다.
| 모델 | 컨텍스트 윈도우 | 최적 용도 |
|-------------------|-------------------|-----------------------------------------------|
| GPT-4 | 8,192 토큰 | 고정확도 작업, 복잡한 추론 |
| GPT-4 Turbo | 128,000 토큰 | 장문 콘텐츠, 문서 분석 |
| GPT-4o & GPT-4o-mini | 128,000 토큰 | 비용 효율적인 대용량 컨텍스트 처리 |
| o3-mini | 200,000 토큰 | 빠른 추론, 복잡한 추론 |
| o1-mini | 128,000 토큰 | 빠른 추론, 복잡한 추론 |
| o1-preview | 128,000 토큰 | 빠른 추론, 복잡한 추론 |
| o1 | 200,000 토큰 | 빠른 추론, 복잡한 추론 |
OpenAI는 정기적으로 모델을 추가하고 이전 스냅샷을 폐기합니다. 현재 모델 ID, 컨텍스트 윈도우, 엔드포인트 호환성, 수명 주기 정보는 [OpenAI 모델 카탈로그](https://developers.openai.com/api/docs/models)를 확인하세요.
**Responses API:**
@@ -215,14 +196,7 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
)
```
https://llama.developer.meta.com/docs/models/ 에 기재된 모든 모델이 지원됩니다.
| 모델 ID | 입력 컨텍스트 길이 | 출력 컨텍스트 길이 | 입력 모달리티 | 출력 모달리티 |
| ------- | ------------------ | ------------------ | ---------------- | ---------------- |
| `meta_llama/Llama-4-Scout-17B-16E-Instruct-FP8` | 128k | 4028 | 텍스트, 이미지 | 텍스트 |
| `meta_llama/Llama-4-Maverick-17B-128E-Instruct-FP8` | 128k | 4028 | 텍스트, 이미지 | 텍스트 |
| `meta_llama/Llama-3.3-70B-Instruct` | 128k | 4028 | 텍스트 | 텍스트 |
| `meta_llama/Llama-3.3-8B-Instruct` | 128k | 4028 | 텍스트 | 텍스트 |
현재 모델 제품군, 모달리티, 컨텍스트 지침은 [Meta Llama 모델 개요](https://ai.meta.com/llama/get-started/)를 확인하세요.
**참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
```bash
@@ -291,10 +265,12 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
CrewAI 프로젝트에서의 예시 사용법:
```python Code
llm = LLM(
model="anthropic/claude-3-sonnet-20240229-v1:0",
temperature=0.7
model="anthropic/claude-sonnet-4-6",
max_tokens=4096
)
```
현재 모델 ID와 기능은 Anthropic의 [모델 개요](https://platform.claude.com/docs/en/about-claude/models/overview)를 확인하고, 프로덕션에서 모델을 고정하기 전에 [모델 지원 중단 표](https://platform.claude.com/docs/en/about-claude/model-deprecations)를 검토하세요.
</Accordion>
<Accordion title="Google (Gemini API)">
@@ -319,8 +295,7 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
from crewai import LLM
llm = LLM(
model="gemini/gemini-2.0-flash",
temperature=0.7,
model="gemini/gemini-3.6-flash",
)
```
@@ -339,8 +314,7 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
from crewai import LLM
llm = LLM(
model="gemini/gemini-2.0-flash",
temperature=0.7
model="gemini/gemini-3.6-flash"
)
```
@@ -352,47 +326,15 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
자세한 내용은 [Vertex AI Express 모드 문서](https://docs.cloud.google.com/vertex-ai/generative-ai/docs/start/quickstart?usertype=apikey)를 참조하세요.
</Info>
### Gemini 모델
Google은 다양한 용도에 최적화된 강력한 모델을 제공합니다.
| 모델 | 컨텍스트 윈도우 | 최적 용도 |
|----------------------------------|-----------------|------------------------------------------------------------------------|
| gemini-2.5-flash-preview-04-17 | 1M 토큰 | 적응형 사고, 비용 효율성 |
| gemini-2.5-pro-preview-05-06 | 1M 토큰 | 향상된 사고 및 추론, 멀티모달 이해, 고급 코딩 등 |
| gemini-2.0-flash | 1M 토큰 | 차세대 기능, 속도, 사고, 실시간 스트리밍 |
| gemini-2.0-flash-lite | 1M 토큰 | 비용 효율성과 낮은 대기 시간 |
| gemini-1.5-flash | 1M 토큰 | 밸런스 잡힌 멀티모달 모델, 대부분의 작업에 적합 |
| gemini-1.5-flash-8B | 1M 토큰 | 가장 빠르고, 비용 효율적, 고빈도 작업에 적합 |
| gemini-1.5-pro | 2M 토큰 | 최고의 성능, 논리적 추론, 코딩, 창의적 협업 등 다양한 추론 작업에 적합 |
전체 모델 목록은 [Gemini 모델 문서](https://ai.google.dev/gemini-api/docs/models)에서 확인할 수 있습니다.
### Gemma
Gemini API를 통해 Google 인프라에서 호스팅되는 [Gemma 모델](https://ai.google.dev/gemma/docs)도 API 키를 이용해 사용할 수 있습니다.
| 모델 | 컨텍스트 윈도우 |
|----------------|----------------|
| gemma-3-1b-it | 32k 토큰 |
| gemma-3-4b-it | 32k 토큰 |
| gemma-3-12b-it | 32k 토큰 |
| gemma-3-27b-it | 128k 토큰 |
Google은 현재 Gemini ID, 기능, 수명 주기 단계를 [Gemini 모델 카탈로그](https://ai.google.dev/gemini-api/docs/models)에 게시합니다. 안정 또는 preview 모델을 선택하기 전에 [지원 중단 일정](https://ai.google.dev/gemini-api/docs/deprecations)을 확인하세요. Gemini API는 [Gemma 모델](https://ai.google.dev/gemma/docs)도 호스팅합니다.
</Accordion>
<Accordion title="Google (Vertex AI)">
Google Cloud Console에서 자격증명을 받아 JSON 파일로 저장한 후, 다음 코드로 로드하세요:
```python Code
import json
file_path = 'path/to/vertex_ai_service_account.json'
# Load the JSON file
with open(file_path, 'r') as file:
vertex_credentials = json.load(file)
# Convert the credentials to a JSON string
vertex_credentials_json = json.dumps(vertex_credentials)
[애플리케이션 기본 사용자 인증 정보](https://cloud.google.com/docs/authentication/provide-credentials-adc)로 인증한 다음, Vertex AI를 사용하도록 네이티브 Gemini 제공업체를 구성하세요:
```toml .env
GOOGLE_GENAI_USE_VERTEXAI=true
GOOGLE_CLOUD_PROJECT=<your-project-id>
GOOGLE_CLOUD_LOCATION=<location>
```
CrewAI 프로젝트에서의 예시 사용법:
@@ -400,27 +342,15 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
from crewai import LLM
llm = LLM(
model="gemini-1.5-pro-latest", # or vertex_ai/gemini-1.5-pro-latest
temperature=0.7,
vertex_credentials=vertex_credentials_json
model="gemini/gemini-3.6-flash"
)
```
Google은 다양한 용도에 최적화된 강력한 모델들을 제공합니다:
사용 가능한 Vertex AI 모델과 리전은 [Vertex AI 모델 정보](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models)를 확인하세요.
| 모델 | 컨텍스트 윈도우 | 최적 용도 |
|----------------------------------|-----------------|------------------------------------------------------------------------|
| gemini-2.5-flash-preview-04-17 | 1M 토큰 | 적응형 사고, 비용 효율성 |
| gemini-2.5-pro-preview-05-06 | 1M 토큰 | 향상된 사고 및 추론, 멀티모달 이해, 고급 코딩 등 |
| gemini-2.0-flash | 1M 토큰 | 차세대 기능, 속도, 사고, 실시간 스트리밍 |
| gemini-2.0-flash-lite | 1M 토큰 | 비용 효율성과 낮은 대기 시간 |
| gemini-1.5-flash | 1M 토큰 | 밸런스 잡힌 멀티모달 모델, 대부분의 작업에 적합 |
| gemini-1.5-flash-8B | 1M 토큰 | 가장 빠르고, 비용 효율적, 고빈도 작업에 적합 |
| gemini-1.5-pro | 2M 토큰 | 최고의 성능, 논리적 추론, 코딩, 창의적 협업 등 다양한 추론 작업에 적합 |
**참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
**참고:** 이 경로는 CrewAI의 네이티브 Gemini 통합을 사용합니다. 프로젝트에 의존성으로 추가하세요:
```bash
uv add 'crewai[litellm]'
uv add "crewai[google-genai]"
```
</Accordion>
@@ -455,7 +385,7 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
CrewAI 프로젝트에서의 예시 사용법:
```python Code
llm = LLM(
model="bedrock/anthropic.claude-3-sonnet-20240229-v1:0"
model="bedrock/us.anthropic.claude-sonnet-4-6"
)
```
@@ -463,34 +393,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
[Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html)은 대표적인 AI 회사들의 여러 파운데이션 모델에 통합 API를 통해 접근할 수 있는 매니지드 서비스로, 안전하고 책임감 있는 AI 응용프로그램 개발을 가능하게 해줍니다.
| 모델 | 컨텍스트 윈도우 | 최적 용도 |
|-----------------------------|--------------------|------------------------------------------------------------------------|
| Amazon Nova Pro | 최대 300k 토큰 | 다양한 작업에서 정확성, 속도, 비용을 균형 있게 제공하는 고성능 모델 |
| Amazon Nova Micro | 최대 128k 토큰 | 텍스트 전용, 최소 레이턴시 응답에 최적화된 비용 효율적 고성능 모델 |
| Amazon Nova Lite | 최대 300k 토큰 | 이미지, 비디오, 텍스트를 아우르는 실시간 멀티모달 처리 |
| Claude 3.7 Sonnet | 최대 128k 토큰 | 복잡한 추론, 코딩 및 AI 에이전트에 적합한 고성능 모델 |
| Claude 3.5 Sonnet v2 | 최대 200k 토큰 | 소프트웨어 공학, 에이전트 기능, 컴퓨터 상호작용에 특화된 최신 모델 |
| Claude 3.5 Sonnet | 최대 200k 토큰 | 다양한 작업에 탁월한 지능 및 추론 제공, 최적의 속도·비용 모델 |
| Claude 3.5 Haiku | 최대 200k 토큰 | 빠르고 컴팩트한 멀티모달 모델, 신속하고 자연스러운 대화에 최적 |
| Claude 3 Sonnet | 최대 200k 토큰 | 지능과 속도의 균형 잡힌 멀티모달 모델, 대규모 배포에 적합 |
| Claude 3 Haiku | 최대 200k 토큰 | 컴팩트한 고속 멀티모달 모델, 신속한 응답과 자연스러운 대화형 상호작용 |
| Claude 3 Opus | 최대 200k 토큰 | 인간 같은 추론과 우수한 문맥 이해로 복잡한 작업 수행 |
| Claude 2.1 | 최대 200k 토큰 | 확장된 컨텍스트, 신뢰도 개선, 로봇화 감소, 장문 및 RAG 적용에 적합 |
| Claude | 최대 100k 토큰 | 복잡한 대화, 창의적 콘텐츠 생성, 정교한 지시 수행에 탁월 |
| Claude Instant | 최대 100k 토큰 | 일상 대화, 분석, 요약, 문서 Q&A 등 빠르고 비용 효율적인 모델 |
| Llama 3.1 405B Instruct | 최대 128k 토큰 | 챗봇, 코딩, 도메인 특화 작업을 위한 합성 데이터 생성 및 추론용 첨단 LLM |
| Llama 3.1 70B Instruct | 최대 128k 토큰 | 복잡한 대화, 우수한 문맥 및 추론, 텍스트 생성 능력 강화 |
| Llama 3.1 8B Instruct | 최대 128k 토큰 | 우수한 언어 이해, 추론, 텍스트 생성 기능의 최첨단 모델 |
| Llama 3 70B Instruct | 최대 8k 토큰 | 복잡한 대화, 우수한 문맥 및 추론, 텍스트 생성 기능 강화 |
| Llama 3 8B Instruct | 최대 8k 토큰 | 첨단 언어 이해력, 추론, 텍스트 생성이 가능한 최첨단 LLM |
| Titan Text G1 - Lite | 최대 4k 토큰 | 영어 과제 및 요약, 콘텐츠 생성에 최적화된 경량 비용 효율적 모델 |
| Titan Text G1 - Express | 최대 8k 토큰 | 일반 언어, 대화, RAG 지원, 영어 및 100여 개 언어 지원 |
| Cohere Command | 최대 4k 토큰 | 사용자의 명령 수행, 실질적 기업 솔루션 제공에 특화된 모델 |
| Jurassic-2 Mid | 최대 8,191 토큰 | 다양한 언어 과제(Q&A, 요약, 생성 등)에 적합한 품질-비용 균형 모델 |
| Jurassic-2 Ultra | 최대 8,191 토큰 | 고급 텍스트 생성과 이해, 분석 및 콘텐츠 제작 등 복잡한 작업 수행 |
| Jamba-Instruct | 최대 256k 토큰 | 비용 효율적인 대용량 문맥 창작, 요약, Q&A에 최적화된 모델 |
| Mistral 7B Instruct | 최대 32k 토큰 | 명령을 따르고, 요청을 완성하며, 창의적 텍스트를 생성하는 LLM |
| Mistral 8x7B Instruct | 최대 32k 토큰 | 명령 및 요청 완성, 창의적 텍스트 생성이 가능한 MOE LLM |
</Accordion>
@@ -543,81 +445,13 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
CrewAI 프로젝트에서의 예시 사용법:
```python Code
llm = LLM(
model="nvidia_nim/meta/llama3-70b-instruct",
model="nvidia_nim/nvidia/nvidia-nemotron-3-ultra-550b-a55b",
temperature=0.7
)
```
Nvidia NIM은 일반 목적 작업부터 특수 목적 응용까지 다양한 용도를 위한 모델 제품군을 제공합니다.
NVIDIA NIM의 호스팅 카탈로그는 자주 변경됩니다. 현재 endpoint를 선택하고 모델 ID, 모달리티, 컨텍스트 제한을 확인하려면 [NVIDIA NIM 모델 카탈로그](https://build.nvidia.com/models)를 사용하세요.
| 모델 | 컨텍스트 윈도우 | 최적 용도 |
|------------------------------------------------------------------------|----------------|---------------------------------------------------------------------|
| nvidia/mistral-nemo-minitron-8b-8k-instruct | 8,192 토큰 | 챗봇, 가상 비서, 콘텐츠 생성을 위한 최신형 소형 언어 모델 |
| nvidia/nemotron-4-mini-hindi-4b-instruct | 4,096 토큰 | 힌디-영어 SLM, 힌디 언어 전용 온디바이스 추론 |
| nvidia/llama-3.1-nemotron-70b-instruct | 128k 토큰 | 더욱 도움이 되는 답변을 위해 커스터마이즈됨 |
| nvidia/llama3-chatqa-1.5-8b | 128k 토큰 | 챗봇, 검색엔진용 맥락 인식 응답 생성에 탁월한 고급 LLM |
| nvidia/llama3-chatqa-1.5-70b | 128k 토큰 | 챗봇, 검색엔진용 맥락 인식 응답 생성에 탁월한 고급 LLM |
| nvidia/vila | 128k 토큰 | 텍스트/이미지/비디오 이해 및 정보성 응답 생성을 지원하는 멀티모달 모델 |
| nvidia/neva-22 | 4,096 토큰 | 텍스트/이미지 이해 및 정보성 응답 생성을 지원하는 멀티모달 모델 |
| nvidia/nemotron-mini-4b-instruct | 8,192 토큰 | 일반 목적 작업 |
| nvidia/usdcode-llama3-70b-instruct | 128k 토큰 | OpenUSD 지식 질의 응답, USD-Python 코드 생성이 가능한 최신 LLM |
| nvidia/nemotron-4-340b-instruct | 4,096 토큰 | 실제 데이터를 모사하는 다양한 합성 데이터 생성 |
| meta/codellama-70b | 100k 토큰 | 자연어 → 코드 및 코드 → 자연어 전환 가능한 LLM |
| meta/llama2-70b | 4,096 토큰 | 텍스트, 코드 생성에 최적화된 최첨단 대형 언어 모델 |
| meta/llama3-8b-instruct | 8,192 토큰 | 최첨단 언어 이해 및 추론, 텍스트 생성 기능 모델 |
| meta/llama3-70b-instruct | 8,192 토큰 | 복잡한 대화, 우수한 문맥 및 추론, 텍스트 생성 |
| meta/llama-3.1-8b-instruct | 128k 토큰 | 최첨단 언어 이해 및 추론, 텍스트 생성 기능의 첨단 모델 |
| meta/llama-3.1-70b-instruct | 128k 토큰 | 복잡한 대화, 우수한 문맥 및 추론, 텍스트 생성 |
| meta/llama-3.1-405b-instruct | 128k 토큰 | 챗봇, 코딩, 도메인 특화 작업 합성 데이터 생성 및 추론 |
| meta/llama-3.2-1b-instruct | 128k 토큰 | 최첨단 소형 언어 이해, 추론, 텍스트 생성 모델 |
| meta/llama-3.2-3b-instruct | 128k 토큰 | 최첨단 소형 언어 이해, 추론, 텍스트 생성 |
| meta/llama-3.2-11b-vision-instruct | 128k 토큰 | 최첨단 소형 언어 이해, 추론, 텍스트 생성 |
| meta/llama-3.2-90b-vision-instruct | 128k 토큰 | 최첨단 소형 언어 이해, 추론, 텍스트 생성 |
| google/gemma-7b | 8,192 토큰 | 문자열의 이해, 변환, 코드 생성을 지원하는 최첨단 텍스트 생성 모델 |
| google/gemma-2b | 8,192 토큰 | 문자열의 이해, 변환, 코드 생성을 지원하는 최첨단 텍스트 생성 모델 |
| google/codegemma-7b | 8,192 토큰 | 코드 생성 및 보완에 특화된 Google Gemma-7B 기반 모델 |
| google/codegemma-1.1-7b | 8,192 토큰 | 코드 생성, 보완, 추론, 명령 수행에 강점을 가진 고급 프로그래밍 모델 |
| google/recurrentgemma-2b | 8,192 토큰 | 긴 시퀀스 생성 시 빠른 추론을 가능케 하는 순환 아키텍처 LLM |
| google/gemma-2-9b-it | 8,192 토큰 | 문자열의 이해, 변환, 코드 생성을 지원하는 최첨단 텍스트 생성 모델 |
| google/gemma-2-27b-it | 8,192 토큰 | 문자열의 이해, 변환, 코드 생성을 지원하는 최첨단 텍스트 생성 모델 |
| google/gemma-2-2b-it | 8,192 토큰 | 문자열의 이해, 변환, 코드 생성을 지원하는 최첨단 텍스트 생성 모델 |
| google/deplot | 512 토큰 | 플롯 이미지를 표로 변환하는 원샷 비주얼 언어 이해 모델 |
| google/paligemma | 8,192 토큰 | 텍스트, 이미지 입력 이해 및 정보성 응답 생성에 능한 비전 언어 모델 |
| mistralai/mistral-7b-instruct-v0.2 | 32k 토큰 | 명령을 따르고, 요청을 완성하며, 창의적 텍스트 생성이 가능한 LLM |
| mistralai/mixtral-8x7b-instruct-v0.1 | 8,192 토큰 | 명령 및 요청 완성, 창의 텍스트 생성이 가능한 MOE LLM |
| mistralai/mistral-large | 4,096 토큰 | 실제 데이터 특성을 모방하는 다양한 합성 데이터 생성 |
| mistralai/mixtral-8x22b-instruct-v0.1 | 8,192 토큰 | 실제 데이터 특성을 모방하는 다양한 합성 데이터 생성 |
| mistralai/mistral-7b-instruct-v0.3 | 32k 토큰 | 명령을 따르고, 요청을 완성하며, 창의적 텍스트 생성이 가능한 LLM |
| nv-mistralai/mistral-nemo-12b-instruct | 128k 토큰 | 추론, 코드, 다국어 작업에 적합한 최첨단 언어 모델; 단일 GPU에서 구동 |
| mistralai/mamba-codestral-7b-v0.1 | 256k 토큰 | 광범위한 프로그래밍 언어 및 작업에서 코드 작성 및 상호작용 전용 모델 |
| microsoft/phi-3-mini-128k-instruct | 128K 토큰 | 수학·논리 추론에 강한 경량 최신 공개 LLM |
| microsoft/phi-3-mini-4k-instruct | 4,096 토큰 | 수학·논리 추론에 강한 경량 최신 공개 LLM |
| microsoft/phi-3-small-8k-instruct | 8,192 토큰 | 수학·논리 추론에 강한 경량 최신 공개 LLM |
| microsoft/phi-3-small-128k-instruct | 128K 토큰 | 수학·논리 추론에 강한 경량 최신 공개 LLM |
| microsoft/phi-3-medium-4k-instruct | 4,096 토큰 | 수학·논리 추론에 강한 경량 최신 공개 LLM |
| microsoft/phi-3-medium-128k-instruct | 128K 토큰 | 수학·논리 추론에 강한 경량 최신 공개 LLM |
| microsoft/phi-3.5-mini-instruct | 128K 토큰 | 지연, 메모리/컴퓨트 한계 환경에서 AI 응용프로그램 구동 가능한 다국어 LLM |
| microsoft/phi-3.5-moe-instruct | 128K 토큰 | 연산 효율적 콘텐츠 생성을 위한 Mixture of Experts 기반 첨단 LLM |
| microsoft/kosmos-2 | 1,024 토큰 | 이미지의 시각적 요소 이해 및 추론을 위한 획기적 멀티모달 모델 |
| microsoft/phi-3-vision-128k-instruct | 128k 토큰 | 이미지에서 고품질 추론이 가능한 최첨단 공개 멀티모달 모델 |
| microsoft/phi-3.5-vision-instruct | 128k 토큰 | 이미지에서 고품질 추론이 가능한 최첨단 공개 멀티모달 모델 |
| databricks/dbrx-instruct | 12k 토큰 | 언어 이해, 코딩, RAG에 최신 성능을 제공하는 범용 LLM |
| snowflake/arctic | 1,024 토큰 | SQL 생성 및 코딩에 집중한 기업용 고효율 추론 모델 |
| aisingapore/sea-lion-7b-instruct | 4,096 토큰 | 동남아 언어 및 문화 다양성을 반영하는 LLM |
| ibm/granite-8b-code-instruct | 4,096 토큰 | 소프트웨어 프로그래밍 LLM, 코드 생성, 완성, 설명, 멀티턴 전환 |
| ibm/granite-34b-code-instruct | 8,192 토큰 | 소프트웨어 프로그래밍 LLM, 코드 생성, 완성, 설명, 멀티턴 전환 |
| ibm/granite-3.0-8b-instruct | 4,096 토큰 | RAG, 요약, 분류, 코드, 에이전틱AI 지원 첨단 소형 언어 모델 |
| ibm/granite-3.0-3b-a800m-instruct | 4,096 토큰 | RAG, 요약, 엔터티 추출, 분류에 최적화된 고효율 Mixture of Experts 모델 |
| mediatek/breeze-7b-instruct | 4,096 토큰 | 실제 데이터 특성을 모방하는 다양한 합성 데이터 생성 |
| upstage/solar-10.7b-instruct | 4,096 토큰 | 지시 따르기, 추론, 수학 등에서 뛰어난 NLP 작업 수행 |
| writer/palmyra-med-70b-32k | 32k 토큰 | 의료 분야에서 정확하고 문맥에 맞는 응답 생성에 선도적인 LLM |
| writer/palmyra-med-70b | 32k 토큰 | 의료 분야에서 정확하고 문맥에 맞는 응답 생성에 선도적인 LLM |
| writer/palmyra-fin-70b-32k | 32k 토큰 | 금융 분석, 보고, 데이터 처리에 특화된 LLM |
| 01-ai/yi-large | 32k 토큰 | 영어, 중국어로 훈련, 챗봇 및 창의적 글쓰기 등 다양한 작업에 사용 |
| deepseek-ai/deepseek-coder-6.7b-instruct | 2k 토큰 | 고급 코드 생성, 완성, 인필링 등의 기능을 제공하는 강력한 코딩 모델 |
| rakuten/rakutenai-7b-instruct | 1,024 토큰 | 언어 이해, 추론, 텍스트 생성이 탁월한 최첨단 LLM |
| rakuten/rakutenai-7b-chat | 1,024 토큰 | 언어 이해, 추론, 텍스트 생성이 탁월한 최첨단 LLM |
| baichuan-inc/baichuan2-13b-chat | 4,096 토큰 | 중국어 및 영어 대화, 코딩, 수학, 지시 따르기, 퀴즈 풀이 지원 |
**참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
```bash
@@ -680,15 +514,12 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
CrewAI 프로젝트에서의 예시 사용법:
```python Code
llm = LLM(
model="groq/llama-3.2-90b-text-preview",
model="groq/qwen/qwen3.6-27b",
temperature=0.7
)
```
| 모델 | 컨텍스트 윈도우 | 최적 용도 |
|-----------------|-------------------|----------------------------------|
| Llama 3.1 70B/8B| 131,072 토큰 | 고성능, 대용량 문맥 작업 |
| Llama 3.2 Series| 8,192 토큰 | 범용 작업 |
| Mixtral 8x7B | 32,768 토큰 | 성능과 문맥의 균형 |
Groq는 production 모델과 preview 모델을 구분하며 모델 ID를 정기적으로 폐기합니다. 프로덕션 모델을 선택하기 전에 [Groq 모델 카탈로그](https://console.groq.com/docs/models)와 [지원 중단 페이지](https://console.groq.com/docs/deprecations)를 확인하세요.
**참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
```bash
@@ -770,11 +601,12 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
CrewAI 프로젝트에서의 예시 사용법:
```python Code
llm = LLM(
model="llama-3.1-sonar-large-128k-online",
base_url="https://api.perplexity.ai/"
model="perplexity/sonar-pro"
)
```
현재 모델 ID와 지원 중단 공지는 [Perplexity 모델 카탈로그](https://docs.perplexity.ai/getting-started/models)와 [changelog](https://docs.perplexity.ai/docs/resources/changelog)를 확인하세요.
**참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
```bash
uv add 'crewai[litellm]'
@@ -810,17 +642,12 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
CrewAI 프로젝트에서의 예시 사용법:
```python Code
llm = LLM(
model="sambanova/Meta-Llama-3.1-8B-Instruct",
model="sambanova/Meta-Llama-3.3-70B-Instruct",
temperature=0.7
)
```
| 모델 | 컨텍스트 윈도우 | 최적 용도 |
|-----------------|---------------------|--------------------------------------|
| Llama 3.1 70B/8B| 최대 131,072 토큰 | 고성능, 대용량 문맥 작업 |
| Llama 3.1 405B | 8,192 토큰 | 고성능, 높은 출력 품질 |
| Llama 3.2 Series| 8,192 토큰 | 범용, 멀티모달 작업 |
| Llama 3.3 70B | 최대 131,072 토큰 | 고성능, 높은 출력 품질 |
| Qwen2 familly | 8,192 토큰 | 고성능, 높은 출력 품질 |
SambaNova Cloud의 호스팅 모델은 CrewAI와 별도로 변경될 수 있습니다. 배포 전에 [models endpoint](https://docs.sambanova.ai/docs/api-reference/models/get-environments-available-model-list-metadata)를 조회하고 [지원 중단 가이드](https://docs.sambanova.ai/docs/en/models/deprecations)를 확인하세요.
**참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
```bash
@@ -838,7 +665,7 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
CrewAI 프로젝트에서의 예시 사용법:
```python Code
llm = LLM(
model="cerebras/llama3.1-70b",
model="cerebras/gpt-oss-120b",
temperature=0.7,
max_tokens=8192
)
@@ -852,6 +679,8 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
- 긴 컨텍스트 윈도우 지원
</Info>
현재 공개 endpoint ID는 [Cerebras 모델 카탈로그](https://inference-docs.cerebras.ai/models/overview)와 [지원 중단 공지](https://inference-docs.cerebras.ai/support/deprecation)를 확인하세요.
**참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
```bash
uv add 'crewai[litellm]'
@@ -926,7 +755,7 @@ CrewAI는 LLM의 스트리밍 응답을 지원하여, 애플리케이션이 출
# 스트리밍이 활성화된 LLM 생성
llm = LLM(
model="openai/gpt-4o",
model="openai/gpt-5.6-terra",
stream=True # 스트리밍 활성화
)
```
@@ -976,7 +805,7 @@ CrewAI는 LLM의 스트리밍 응답을 지원하여, 애플리케이션이 출
my_listener = MyCustomListener()
llm = LLM(model="gpt-4o-mini", temperature=0, stream=True)
llm = LLM(model="openai/gpt-5.6-terra", stream=True)
researcher = Agent(
role="About User",
@@ -1012,6 +841,8 @@ CrewAI는 LLM의 스트리밍 응답을 지원하여, 애플리케이션이 출
CrewAI는 Pydantic 모델을 사용하여 `response_format`을 정의함으로써 LLM 호출에서 구조화된 응답을 지원합니다. 이를 통해 프레임워크가 출력을 자동으로 파싱하고 검증할 수 있어, 수동 후처리 없이도 응답을 애플리케이션에 쉽게 통합할 수 있습니다.
구조화된 출력 지원은 제공업체와 모델에 따라 다릅니다. 프로덕션에서 구조화된 응답에 의존하기 전에 선택한 모델을 테스트하세요.
예를 들어, 예상되는 응답 구조를 나타내는 Pydantic 모델을 정의하고 LLM을 인스턴스화할 때 `response_format`으로 전달할 수 있습니다. 이 모델은 LLM 출력을 구조화된 Python 객체로 변환하는 데 사용됩니다.
```python Code
@@ -1023,7 +854,7 @@ class Dog(BaseModel):
breed: str
llm = LLM(model="gpt-4o", response_format=Dog)
llm = LLM(model="openai/gpt-5.6-terra", response_format=Dog)
response = llm.call(
"Analyze the following messages and return the name, age, and breed. "
@@ -1052,8 +883,8 @@ LLM 설정을 최대한 활용하는 방법을 알아보세요:
# 3. 큰 컨텍스트에 대한 작업 분할
llm = LLM(
model="gpt-4",
max_tokens=4000, # 응답 길이 제한
model="openai/gpt-5.6-terra",
max_completion_tokens=4000, # 응답 길이 제한
)
```
@@ -1077,15 +908,14 @@ LLM 설정을 최대한 활용하는 방법을 알아보세요:
```python
# 모델을 적절한 설정으로 구성
llm = LLM(
model="openai/gpt-4-turbo-preview",
temperature=0.7, # 작업에 따라 조정
max_tokens=4096, # 출력 요구 사항에 맞게 설정
timeout=300 # 복잡한 작업을 위한 더 긴 타임아웃
model="openai/gpt-5.6-terra",
reasoning_effort="medium",
max_completion_tokens=4096,
timeout=300
)
```
<Tip>
- 사실 기반 응답에는 낮은 temperature(0.1~0.3)
- 창의적인 작업에는 높은 temperature(0.7~0.9)
선택한 모델이 지원하는 제어 옵션을 사용하세요. 제공자에 따라 `temperature`, reasoning 또는 thinking 수준, 혹은 원하는 스타일과 변동성을 정의하는 프롬프트 지침을 사용할 수 있습니다.
</Tip>
</Step>

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -24,7 +24,25 @@ mode: "wide"
DML을 명시적으로 활성화하지 않으면 쓰기 작업(`INSERT`, `UPDATE`, `DELETE`, `DROP`, `CREATE`, `ALTER`, `TRUNCATE` 등)을 실행하려고 할 때 오류가 발생합니다.
읽기 전용 모드에서는 세미콜론이 포함된 다중 구문 쿼리(예: `SELECT 1; DROP TABLE users`)도 인젝션 공격을 방지하기 위해 차단니다.
읽기 전용 모드는 우회 경로를 통한 쓰기도 차단니다:
| 읽기 전용 모드에서 차단됨 | 예시 |
| --- | --- |
| 다중 구문 쿼리 | `SELECT 1; DROP TABLE users` |
| 쓰기 CTE(`MATERIALIZED` 표기 포함) | `WITH d AS MATERIALIZED (DELETE FROM users RETURNING *) SELECT * FROM d` |
| CTE 뒤에 오는 쓰기 작업 | `WITH d AS (SELECT 1) DELETE FROM users` |
| 인자를 실제로 실행하는 `EXPLAIN ANALYZE` | `EXPLAIN ANALYZE DELETE FROM users` |
| 데이터베이스 서버 파일시스템에 대한 쓰기 | `SELECT * FROM users INTO OUTFILE '/var/www/shell.php'` |
| 서버 파일시스템에 접근하거나 새 연결을 여는 함수 | `SELECT pg_read_file('/etc/passwd')`, `dblink_exec(...)` |
| 읽기 전용임을 확인할 수 없는 `WITH` 구문 | `WITH d AS DELETE FROM users` |
구문은 문자열 리터럴과 주석을 가린 상태에서 분석됩니다. 따라서 리터럴 안에 숨은 키워드는 명령으로 오인되지 않고(`SELECT 'DROP TABLE users'`는 허용), 키워드 사이에 삽입된 주석이 명령을 숨기지도 못합니다(`EXPLAIN /*x*/ ANALYZE DELETE ...`는 차단). 문자열 리터럴 안의 세미콜론은 구문 구분자로 세지 않으므로 `SELECT ';'`는 유효한 단일 구문입니다.
읽기 전용 모드에서는 트랜잭션에 `SET TRANSACTION READ ONLY`도 적용하므로, PostgreSQL과 MySQL은 구문 표기 방식과 무관하게 데이터베이스 차원에서 쓰기를 거부합니다. 해당 구문을 지원하지 않는 백엔드(SQLite, SQL Server, Snowflake)는 디버그 로그를 남기고 구문 검증에만 의존합니다. 파싱이 아니라 읽기 전용 역할에 의존해야 하는 이유가 하나 더 있는 셈입니다.
<Warning>
내장된 읽기 전용 검사는 완전한 경계가 아니라 심층 방어 수단입니다. 이 검사는 구문 텍스트를 검사하며 SQL은 데이터베이스마다 다릅니다. `SELECT`로 시작하는 구문도 데이터베이스 서버의 파일시스템에 접근하거나(`SELECT ... INTO OUTFILE`, `pg_read_file()`) 부수 효과가 있는 함수를 호출할 수 있습니다. 알려진 경로는 명시적으로 차단하지만, 완전한 통제 수단은 `db_uri`에 부여하는 권한뿐입니다. **최소 권한의 읽기 전용 데이터베이스 역할을 사용하십시오.**
</Warning>
### 쓰기 작업 활성화

View File

@@ -13,8 +13,7 @@ mode: "wide"
FileReadTool은 crewai_tools 패키지 내에서 파일 읽기와 콘텐츠 검색을 용이하게 하는 기능 모음입니다.
이 모음에는 배치 텍스트 파일 처리, 런타임 구성 파일 읽기, 분석을 위한 데이터 가져오기 등 다양한 도구가 포함되어 있습니다.
`.txt`, `.csv`, `.json` 등 다양한 텍스트 기반 파일 형식을 지원합니다. 파일 유형에 따라 이 모음은
JSON 콘텐츠를 Python 딕셔너리로 변환하여 사용을 쉽게 하는 등 특화된 기능을 제공합니다.
`.txt`, `.csv`, `.json` 등 다양한 텍스트 기반 파일 형식을 지원합니다. 콘텐츠는 항상 일반 텍스트로 반환됩니다.
## 설치

View File

@@ -32,7 +32,11 @@ from crewai_tools import FileWriterTool
file_writer_tool = FileWriterTool()
# Write content to a file in a specified directory
result = file_writer_tool._run('example.txt', 'This is a test content.', 'test_directory')
result = file_writer_tool.run(
filename='example.txt',
content='This is a test content.',
directory='test_directory',
)
print(result)
```

View File

@@ -4,6 +4,125 @@ description: "Atualizações de produto, melhorias e correções do CrewAI"
icon: "clock"
mode: "wide"
---
<Update label="29 jul 2026">
## v1.15.9
[Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.15.9)
## O que mudou
### Recursos
- Exibir falhas de ferramentas em vez de relatá-las como sucesso
- Emitir FlowFailedEvent quando uma execução de fluxo falha
- Implementar divulgação progressiva para habilidades
### Documentação
- Atualizar snapshot e changelog para v1.15.8
## Contributors
@github-actions[bot], @joaomdmoura, @lorenzejay, @lucasgomide
</Update>
<Update label="28 jul 2026">
## v1.15.8
[Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.15.8)
## O que Mudou
### Funcionalidades
- Adicionar WaitTool para pausar em trabalhos de longa duração.
### Correções de Bugs
- Corrigir FileWriterTool para gravações e abordar problemas no arquivo ferramenta.
- Marcar E2B_API_KEY como uma variável de ambiente obrigatória para ferramentas E2B.
### Documentação
- Atualizar orientações sobre a disponibilidade do modelo.
## Contribuidores
@github-actions[bot], @joaomdmoura, @lucasgomide, @oalami, @thiagomoretto
</Update>
<Update label="26 jul 2026">
## v1.15.7
[Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.15.7)
## O que Mudou
### Correções de Bugs
- Resolver habilidades de registro através do cliente CrewAI+ do runtime
- Recuperar das ferramentas GPT-5.6 + reasoning_effort 400
- Fazer chamadas de ferramentas funcionarem no caminho da API de Respostas
- Roteirizar modelos apenas de respostas em vez de falhar com 404
- Atualizar bedrock-agentcore para corrigir CVE-2026-16796
### Observabilidade
- Emitir eventos de uso de habilidades em tempo de execução para observabilidade
### Documentação
- Adicionar snapshot e changelog para v1.15.7a1
## Contributors
@alex-clawd, @joaomdmoura, @lorenzejay
</Update>
<Update label="26 jul 2026">
## v1.15.7a1
[Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.15.7a1)
## O Que Mudou
### Correções de Bugs
- Corrigir a resolução de habilidades do registro através do cliente CrewAI+ do runtime.
- Recuperar dos erros 400 de tools e reasoning_effort do GPT-5.6.
- Fazer a chamada de ferramentas funcionar no caminho da API de Respostas.
- Roteirizar modelos apenas de respostas para evitar erros 404.
- Atualizar a dependência bedrock-agentcore para corrigir o CVE-2026-16796.
### Observabilidade
- Emitir eventos de uso de habilidades em tempo de execução para melhorar a observabilidade.
### Documentação
- Atualizações de snapshot e changelog para a versão 1.15.6.
## Contributors
@alex-clawd, @joaomdmoura, @lorenzejay
</Update>
<Update label="24 jul 2026">
## v1.15.6
[Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.15.6)
## O que mudou
### Correções de Bugs
- Corrigir a detecção de blocos de uso da ferramenta de pré-visualização da Anthropic.
- Preservar os nomes das propriedades do esquema de ferramenta estrito.
- Disparar o hook execution_end em execuções de equipe e fluxo com falha.
- Lidar com get_agent assíncrono em load_agent_from_repository.
- Corrigir problemas de resolução de dependências.
### Documentação
- Snapshot e changelog para v1.15.5.
## Contributors
@alex-clawd, @iris-clawd, @lorenzejay, @lucasgomide, @theCyberTech, @vinibrsl
</Update>
<Update label="20 jul 2026">
## v1.15.5

View File

@@ -256,6 +256,7 @@ O CrewAI fornece uma ampla variedade de eventos para escuta:
- **FlowCreatedEvent**: Emitido ao criar um Flow
- **FlowStartedEvent**: Emitido ao iniciar a execução de um Flow
- **FlowFinishedEvent**: Emitido ao concluir a execução de um Flow
- **FlowFailedEvent**: Emitido quando a execução de um Flow falha. Contém o nome do flow e a exceção que encerrou a execução.
- **FlowPausedEvent**: Emitido quando um Flow é pausado aguardando feedback humano. Contém o nome do flow, ID do flow, nome do método, estado atual, mensagem exibida ao solicitar feedback e lista opcional de resultados possíveis para roteamento.
- **FlowPlotEvent**: Emitido ao plotar um Flow
- **MethodExecutionStartedEvent**: Emitido ao iniciar a execução de um método do Flow

View File

@@ -21,7 +21,7 @@ Modelos de Linguagem de Grande Escala (LLMs) são a inteligência central por tr
A janela de contexto determina quanto texto um LLM pode processar de uma só vez. Janelas maiores (por exemplo, 128K tokens) permitem mais contexto, porém podem ser mais caras e lentas.
</Card>
<Card title="Temperatura" icon="temperature-three-quarters">
A temperatura (0.0 a 1.0) controla a aleatoriedade das respostas. Valores mais baixos (ex.: 0.2) produzem respostas mais focadas e determinísticas, enquanto valores mais altos (ex.: 0.8) aumentam criatividade e variabilidade.
A temperatura é um controle de amostragem compatível com alguns modelos. Valores mais baixos geralmente tornam a amostragem mais focada, enquanto valores mais altos aumentam a variabilidade. Alguns modelos de raciocínio mais recentes ignoram, desaconselham ou rejeitam esse parâmetro; consulte a documentação do modelo escolhido antes de defini-lo.
</Card>
<Card title="Seleção de Provedor" icon="server">
Cada provedor de LLM (ex.: OpenAI, Anthropic, Google) oferece modelos diferentes, com capacidades, preços e recursos variados. Escolha conforme suas necessidades de precisão, velocidade e custo.
@@ -37,7 +37,7 @@ Existem diferentes locais no código do CrewAI onde você pode especificar o mod
A maneira mais simples de começar. Defina o modelo diretamente em seu ambiente, usando um arquivo `.env` ou no código do seu aplicativo. Se você utilizou `crewai create` para iniciar seu projeto, já estará configurado.
```bash .env
MODEL=model-id # e.g. gpt-4o, gemini-2.0-flash, claude-3-sonnet-...
MODEL=provider/model-id # e.g. openai/gpt-5.6-terra
# Lembre-se de definir suas chaves de API aqui também. Veja a seção
# do Provedor abaixo.
@@ -56,7 +56,7 @@ Existem diferentes locais no código do CrewAI onde você pode especificar o mod
goal: Conduct comprehensive research and analysis
backstory: A dedicated research professional with years of experience
verbose: true
llm: provider/model-id # e.g. openai/gpt-4o, google/gemini-2.0-flash, anthropic/claude...
llm: provider/model-id # e.g. anthropic/claude-sonnet-4-6
# (veja exemplos de configuração de provedores abaixo para mais)
```
@@ -75,32 +75,24 @@ Existem diferentes locais no código do CrewAI onde você pode especificar o mod
from crewai import LLM
# Configuração básica
llm = LLM(model="model-id-here") # gpt-4o, gemini-2.0-flash, anthropic/claude...
llm = LLM(model="provider/model-id") # e.g. gemini/gemini-3.6-flash
# Configuração avançada com parâmetros detalhados
llm = LLM(
model="openai/gpt-4",
temperature=0.8,
max_tokens=150,
top_p=0.9,
frequency_penalty=0.1,
presence_penalty=0.1,
response_format={"type":"json"},
stop=["FIM"],
seed=42
model="provider/model-id",
timeout=120,
max_tokens=4000,
response_format={"type": "json"}, # Para saídas estruturadas
)
```
<Info>
Explicações dos parâmetros:
- `temperature`: Controla a aleatoriedade (0.0-1.0)
- `timeout`: Tempo máximo de espera pela resposta
- `max_tokens`: Limita o comprimento da resposta
- `top_p`: Alternativa à temperatura para amostragem
- `frequency_penalty`: Reduz repetição de palavras
- `presence_penalty`: Incentiva novos tópicos
- `response_format`: Especifica formato de saída
- `seed`: Garante resultados consistentes
Controles de amostragem como `temperature` e `top_p`, parâmetros de penalidade, nomes de limites de tokens e controles de raciocínio são específicos de cada modelo. Adicione-os somente quando o provedor e o modelo escolhidos oferecerem suporte. Consulte os exemplos de provedores abaixo e a documentação do modelo do provedor.
</Info>
</Tab>
</Tabs>
@@ -119,6 +111,10 @@ Existem diferentes locais no código do CrewAI onde você pode especificar o mod
O CrewAI suporta uma grande variedade de provedores de LLM, cada um com recursos, métodos de autenticação e capacidades de modelo únicos.
Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, configurar e otimizar o LLM que melhor atende às necessidades do seu projeto.
<Warning>
A disponibilidade dos modelos muda com frequência e pode variar por conta, região e plataforma de nuvem. Os exemplos abaixo usam modelos atuais no momento da redação, mas não são listas completas de suporte. Antes de implantar, confirme o ID e o estado do ciclo de vida do modelo no catálogo vinculado do provedor.
</Warning>
<AccordionGroup>
<Accordion title="OpenAI">
Defina as seguintes variáveis de ambiente no seu arquivo `.env`:
@@ -137,28 +133,13 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
from crewai import LLM
llm = LLM(
model="openai/gpt-4",
temperature=0.8,
max_tokens=150,
top_p=0.9,
frequency_penalty=0.1,
presence_penalty=0.1,
stop=["FIM"],
seed=42
model="openai/gpt-5.6-terra",
reasoning_effort="medium",
max_completion_tokens=4000
)
```
OpenAI é um dos líderes em modelos LLM com uma ampla gama de modelos e recursos.
| Modelo | Janela de Contexto | Melhor Para |
|----------------------|---------------------|------------------------------------------|
| GPT-4 | 8.192 tokens | Tarefas de alta precisão, raciocínio complexo |
| GPT-4 Turbo | 128.000 tokens | Conteúdo longo, análise de documentos |
| GPT-4o & GPT-4o-mini | 128.000 tokens | Processamento de contexto amplo com bom custo-benefício |
| o3-mini | 200.000 tokens | Raciocínio rápido, tarefas complexas |
| o1-mini | 128.000 tokens | Raciocínio rápido, tarefas complexas |
| o1-preview | 128.000 tokens | Raciocínio rápido, tarefas complexas |
| o1 | 200.000 tokens | Raciocínio rápido, tarefas complexas |
A OpenAI adiciona modelos e desativa snapshots antigos regularmente. Consulte o [catálogo de modelos da OpenAI](https://developers.openai.com/api/docs/models) para obter IDs atuais, janelas de contexto, compatibilidade com endpoints e informações de ciclo de vida.
**Responses API:**
@@ -215,14 +196,7 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
)
```
Todos os modelos listados em https://llama.developer.meta.com/docs/models/ são suportados.
| ID do Modelo | Comprimento contexto entrada | Comprimento contexto saída | Modalidades de entrada | Modalidades de saída |
| --- | --- | --- | --- | --- |
| `meta_llama/Llama-4-Scout-17B-16E-Instruct-FP8` | 128k | 4028 | Texto, Imagem | Texto |
| `meta_llama/Llama-4-Maverick-17B-128E-Instruct-FP8` | 128k | 4028 | Texto, Imagem | Texto |
| `meta_llama/Llama-3.3-70B-Instruct` | 128k | 4028 | Texto | Texto |
| `meta_llama/Llama-3.3-8B-Instruct` | 128k | 4028 | Texto | Texto |
Consulte a [visão geral dos modelos Meta Llama](https://ai.meta.com/llama/get-started/) para conhecer as famílias de modelos, modalidades e orientações de contexto atuais.
**Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
```bash
@@ -291,10 +265,12 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
Exemplo de uso em seu projeto CrewAI:
```python Code
llm = LLM(
model="anthropic/claude-3-sonnet-20240229-v1:0",
temperature=0.7
model="anthropic/claude-sonnet-4-6",
max_tokens=4096
)
```
Consulte a [visão geral dos modelos](https://platform.claude.com/docs/en/about-claude/models/overview) da Anthropic para obter IDs e capacidades atuais e revise a [tabela de descontinuação](https://platform.claude.com/docs/en/about-claude/model-deprecations) antes de fixar um modelo em produção.
</Accordion>
<Accordion title="Google (Gemini API)">
@@ -319,8 +295,7 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
from crewai import LLM
llm = LLM(
model="gemini/gemini-2.0-flash",
temperature=0.7,
model="gemini/gemini-3.6-flash",
)
```
@@ -339,8 +314,7 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
from crewai import LLM
llm = LLM(
model="gemini/gemini-2.0-flash",
temperature=0.7
model="gemini/gemini-3.6-flash"
)
```
@@ -352,47 +326,15 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
Para mais detalhes, consulte a [documentação do Vertex AI Express mode](https://docs.cloud.google.com/vertex-ai/generative-ai/docs/start/quickstart?usertype=apikey).
</Info>
### Modelos Gemini
O Google oferece uma variedade de modelos poderosos otimizados para diferentes casos de uso.
| Modelo | Janela de Contexto | Melhor Para |
|----------------------------------|--------------------|---------------------------------------------------------------------|
| gemini-2.5-flash-preview-04-17 | 1M tokens | Pensamento adaptativo, eficiência de custo |
| gemini-2.5-pro-preview-05-06 | 1M tokens | Pensamento e raciocínio avançados, compreensão multimodal, codificação avançada, etc. |
| gemini-2.0-flash | 1M tokens | Próxima geração de recursos, velocidade, raciocínio e streaming em tempo real |
| gemini-2.0-flash-lite | 1M tokens | Eficiência de custo e baixa latência |
| gemini-1.5-flash | 1M tokens | Modelo multimodal equilibrado, bom para maioria das tarefas |
| gemini-1.5-flash-8B | 1M tokens | Mais rápido, mais eficiente em custo, adequado para tarefas de alta frequência |
| gemini-1.5-pro | 2M tokens | Melhor desempenho para uma ampla variedade de tarefas de raciocínio, incluindo lógica, codificação e colaboração criativa |
A lista completa de modelos está disponível na [documentação dos modelos Gemini](https://ai.google.dev/gemini-api/docs/models).
### Gemma
A API Gemini também permite uso de sua chave de API para acessar [modelos Gemma](https://ai.google.dev/gemma/docs) hospedados na infraestrutura Google.
| Modelo | Janela de Contexto |
|----------------|-------------------|
| gemma-3-1b-it | 32k tokens |
| gemma-3-4b-it | 32k tokens |
| gemma-3-12b-it | 32k tokens |
| gemma-3-27b-it | 128k tokens |
O Google publica IDs atuais, capacidades e estágios do ciclo de vida no [catálogo de modelos Gemini](https://ai.google.dev/gemini-api/docs/models). Consulte o [cronograma de descontinuação](https://ai.google.dev/gemini-api/docs/deprecations) antes de escolher um modelo estável ou preview. A API Gemini também hospeda [modelos Gemma](https://ai.google.dev/gemma/docs).
</Accordion>
<Accordion title="Google (Vertex AI)">
Obtenha as credenciais pelo Google Cloud Console, salve em um arquivo JSON e carregue com o código a seguir:
```python Code
import json
file_path = 'path/to/vertex_ai_service_account.json'
# Carregar o arquivo JSON
with open(file_path, 'r') as file:
vertex_credentials = json.load(file)
# Converter credenciais em string JSON
vertex_credentials_json = json.dumps(vertex_credentials)
Autentique-se com as [Credenciais Padrão do Aplicativo](https://cloud.google.com/docs/authentication/provide-credentials-adc) e configure o provedor Gemini nativo para usar o Vertex AI:
```toml .env
GOOGLE_GENAI_USE_VERTEXAI=true
GOOGLE_CLOUD_PROJECT=<your-project-id>
GOOGLE_CLOUD_LOCATION=<location>
```
Exemplo de uso em seu projeto CrewAI:
@@ -400,27 +342,15 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
from crewai import LLM
llm = LLM(
model="gemini-1.5-pro-latest", # or vertex_ai/gemini-1.5-pro-latest
temperature=0.7,
vertex_credentials=vertex_credentials_json
model="gemini/gemini-3.6-flash"
)
```
O Google oferece uma variedade de modelos poderosos otimizados para diferentes casos de uso:
Consulte as [informações de modelos do Vertex AI](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models) para verificar modelos e regiões disponíveis.
| Modelo | Janela de Contexto | Melhor Para |
|----------------------------------|--------------------|---------------------------------------------------------------------|
| gemini-2.5-flash-preview-04-17 | 1M tokens | Pensamento adaptativo, eficiência de custo |
| gemini-2.5-pro-preview-05-06 | 1M tokens | Pensamento e raciocínio avançados, compreensão multimodal, codificação avançada, etc. |
| gemini-2.0-flash | 1M tokens | Próxima geração de recursos, velocidade, raciocínio e streaming em tempo real |
| gemini-2.0-flash-lite | 1M tokens | Eficiência de custo e baixa latência |
| gemini-1.5-flash | 1M tokens | Modelo multimodal equilibrado, bom para maioria das tarefas |
| gemini-1.5-flash-8B | 1M tokens | Mais rápido, mais eficiente em custo, adequado para tarefas de alta frequência |
| gemini-1.5-pro | 2M tokens | Melhor desempenho para uma ampla variedade de tarefas de raciocínio, incluindo lógica, codificação e colaboração criativa |
**Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
**Nota:** Esta configuração usa a integração Gemini nativa do CrewAI. Adicione-a como dependência ao seu projeto:
```bash
uv add 'crewai[litellm]'
uv add "crewai[google-genai]"
```
</Accordion>
@@ -455,7 +385,7 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
Exemplo de uso em seu projeto CrewAI:
```python Code
llm = LLM(
model="bedrock/anthropic.claude-3-sonnet-20240229-v1:0"
model="bedrock/us.anthropic.claude-sonnet-4-6"
)
```
@@ -463,34 +393,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
[Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) é um serviço gerenciado que fornece acesso a múltiplos modelos fundamentais dos principais provedores de IA através de uma API unificada, permitindo o desenvolvimento seguro e responsável de aplicações de IA.
| Modelo | Janela de Contexto | Melhor Para |
|--------------------------|------------------------|---------------------------------------------------------------------|
| Amazon Nova Pro | Até 300k tokens | Alto desempenho, equilíbrio entre precisão, velocidade e custo em tarefas diversas. |
| Amazon Nova Micro | Até 128k tokens | Modelo texto-only de alta performance, custo-benefício, otimizado para baixa latência. |
| Amazon Nova Lite | Até 300k tokens | Alto desempenho, processamento multimodal acessível para texto, imagem, vídeo em tempo real. |
| Claude 3.7 Sonnet | Até 128k tokens | Alto desempenho para raciocínio complexo, programação & agentes de IA|
| Claude 3.5 Sonnet v2 | Até 200k tokens | Modelo avançado especializado em engenharia de software, capacidades agenticas e interação computacional com custo otimizado. |
| Claude 3.5 Sonnet | Até 200k tokens | Alto desempenho com inteligência e raciocínio excepcionais, equilíbrio entre velocidade-custo. |
| Claude 3.5 Haiku | Até 200k tokens | Modelo multimodal rápido e compacto, otimizado para respostas rápidas e interações humanas naturais |
| Claude 3 Sonnet | Até 200k tokens | Modelo multimodal equilibrando inteligência e velocidade para grandes volumes de uso. |
| Claude 3 Haiku | Até 200k tokens | Compacto, multimodal, otimizado para respostas rápidas e diálogo natural |
| Claude 3 Opus | Até 200k tokens | Modelo multimodal mais avançado para tarefas complexas com raciocínio humano e entendimento contextual superior. |
| Claude 2.1 | Até 200k tokens | Versão aprimorada com janela de contexto aumentada, maior confiabilidade, menos alucinações para aplicações longas e RAG |
| Claude | Até 100k tokens | Modelo versátil para diálogos sofisticados, conteúdo criativo e instruções precisas. |
| Claude Instant | Até 100k tokens | Modelo rápido e de baixo custo para tarefas diárias, como diálogos, análise, sumarização e Q&A em documentos |
| Llama 3.1 405B Instruct | Até 128k tokens | LLM avançado para geração de dados sintéticos, distilação e inferência para chatbots, programação, tarefas de domínio específico. |
| Llama 3.1 70B Instruct | Até 128k tokens | Potencializa conversas complexas com entendimento contextual superior, raciocínio e geração de texto. |
| Llama 3.1 8B Instruct | Até 128k tokens | Modelo de última geração, entendimento de linguagem, raciocínio e geração de texto. |
| Llama 3 70B Instruct | Até 8k tokens | Potencializa conversas complexas com entendimento contextual superior, raciocínio e geração de texto. |
| Llama 3 8B Instruct | Até 8k tokens | LLM de última geração com excelente desempenho em linguagem e geração de texto. |
| Titan Text G1 - Lite | Até 4k tokens | Modelo leve e econômico para tarefas em inglês e ajuste fino, focado em sumarização e geração de conteúdo. |
| Titan Text G1 - Express | Até 8k tokens | Modelo versátil para tarefas gerais de linguagem, chat e aplicações RAG com suporte a inglês e 100+ línguas. |
| Cohere Command | Até 4k tokens | Modelo especializado em seguir comandos do usuário e entregar soluções empresariais práticas. |
| Jurassic-2 Mid | Até 8.191 tokens | Modelo econômico equilibrando qualidade e custo para tarefas como Q&A, sumarização e geração de conteúdo. |
| Jurassic-2 Ultra | Até 8.191 tokens | Geração avançada de texto e compreensão, excelente em análise e criação de conteúdo complexo. |
| Jamba-Instruct | Até 256k tokens | Modelo com janela de contexto extendida para geração de texto, sumarização e Q&A de baixo custo. |
| Mistral 7B Instruct | Até 32k tokens | LLM atende instruções, solicitações e gera texto criativo. |
| Mistral 8x7B Instruct | Até 32k tokens | MOE LLM que atende instruções, solicitações e gera texto criativo. |
</Accordion>
<Accordion title="Amazon SageMaker">
@@ -542,81 +444,13 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
Exemplo de uso em seu projeto CrewAI:
```python Code
llm = LLM(
model="nvidia_nim/meta/llama3-70b-instruct",
model="nvidia_nim/nvidia/nvidia-nemotron-3-ultra-550b-a55b",
temperature=0.7
)
```
O Nvidia NIM oferece uma suíte abrangente de modelos para diversos usos, desde tarefas gerais até aplicações especializadas.
O catálogo hospedado do NVIDIA NIM muda com frequência. Use o [catálogo de modelos NVIDIA NIM](https://build.nvidia.com/models) para escolher um endpoint atual e confirmar o ID, as modalidades e os limites de contexto.
| Modelo | Janela de Contexto | Melhor Para |
|--------------------------------------------------------------------------|--------------------|---------------------------------------------------------------------|
| nvidia/mistral-nemo-minitron-8b-8k-instruct | 8.192 tokens | Modelo pequeno de linguagem topo de linha para chatbots, assistentes virtuais e geração de conteúdo. |
| nvidia/nemotron-4-mini-hindi-4b-instruct | 4.096 tokens | SLM bilíngue Hindi-Inglês para inferência no dispositivo, específico para língua hindi. |
| nvidia/llama-3.1-nemotron-70b-instruct | 128k tokens | Personalizado para respostas mais úteis |
| nvidia/llama3-chatqa-1.5-8b | 128k tokens | LLM avançado para respostas contextuais de alta qualidade em chatbots e mecanismos de busca. |
| nvidia/llama3-chatqa-1.5-70b | 128k tokens | LLM avançado para respostas contextuais de alta qualidade para chatbots e mecanismos de busca. |
| nvidia/vila | 128k tokens | Modelo multmodal visão-linguagem para compreensão de texto/img/vídeo com respostas informativas |
| nvidia/neva-22 | 4.096 tokens | Modelo de visão-linguagem multimodal para compreensão textos/imagens e respostas informativas |
| nvidia/nemotron-mini-4b-instruct | 8.192 tokens | Tarefas gerais |
| nvidia/usdcode-llama3-70b-instruct | 128k tokens | LLM de ponta para queries OpenUSD e geração de código USD-Python. |
| nvidia/nemotron-4-340b-instruct | 4.096 tokens | Gera dados sintéticos diversos simulando características reais. |
| meta/codellama-70b | 100k tokens | LLM capaz de gerar código a partir de linguagem natural e vice-versa.|
| meta/llama2-70b | 4.096 tokens | Modelo de IA avançado para geração de textos e códigos. |
| meta/llama3-8b-instruct | 8.192 tokens | LLM de última geração, entendimento de linguagem, raciocínio e geração de texto. |
| meta/llama3-70b-instruct | 8.192 tokens | Potencializa conversas complexas com entendimento contextual superior, raciocínio e geração de texto.|
| meta/llama-3.1-8b-instruct | 128k tokens | Modelo compacto de última geração, com compreensão, raciocínio e geração de texto superior. |
| meta/llama-3.1-70b-instruct | 128k tokens | Potencializa conversas complexas com entendimento contextual superior, raciocínio e geração de texto. |
| meta/llama-3.1-405b-instruct | 128k tokens | LLM avançado para geração sintética de dados, destilação e inferência para chatbots, código, tarefas de domínio específico. |
| meta/llama-3.2-1b-instruct | 128k tokens | Pequeno modelo de linguagem de última geração, entendimento, raciocínio e geração textual.|
| meta/llama-3.2-3b-instruct | 128k tokens | Pequeno modelo de linguagem de última geração, entendimento, raciocínio e geração textual.|
| meta/llama-3.2-11b-vision-instruct | 128k tokens | Pequeno modelo de linguagem de última geração, entendimento, raciocínio e geração textual multimodal.|
| meta/llama-3.2-90b-vision-instruct | 128k tokens | Pequeno modelo de linguagem de última geração, entendimento, raciocínio e geração textual multimodal.|
| google/gemma-7b | 8.192 tokens | Modelo avançado de geração de texto, compreensão, transformação e programação.|
| google/gemma-2b | 8.192 tokens | Modelo avançado de geração de texto, compreensão, transformação e programação.|
| google/codegemma-7b | 8.192 tokens | Modelo avançado baseado no Gemma-7B do Google, especializado em geração de códigos e autocomplete.|
| google/codegemma-1.1-7b | 8.192 tokens | Modelo avançado para geração, complemento, raciocínio e instrução em código.|
| google/recurrentgemma-2b | 8.192 tokens | Modelo baseado em arquitetura recorrente para inferência mais rápida em sequências longas.|
| google/gemma-2-9b-it | 8.192 tokens | Modelo avançado de geração de texto, compreensão, transformação e programação.|
| google/gemma-2-27b-it | 8.192 tokens | Modelo avançado de geração de texto, compreensão, transformação e programação.|
| google/gemma-2-2b-it | 8.192 tokens | Modelo avançado de geração de texto, compreensão, transformação e programação.|
| google/deplot | 512 tokens | Modelo visual por linguagem para entender gráficos e converter em tabelas.|
| google/paligemma | 8.192 tokens | Modelo visão-linguagem experto em compreender texto e visual, gerando respostas informativas.|
| mistralai/mistral-7b-instruct-v0.2 | 32k tokens | LLM que segue instruções, completa pedidos e gera texto criativo. |
| mistralai/mixtral-8x7b-instruct-v0.1 | 8.192 tokens | MOE LLM para seguir instruções e gerar versões criativas de texto. |
| mistralai/mistral-large | 4.096 tokens | Geração de dados sintéticos. |
| mistralai/mixtral-8x22b-instruct-v0.1 | 8.192 tokens | Geração de dados sintéticos. |
| mistralai/mistral-7b-instruct-v0.3 | 32k tokens | LLM que segue instruções, completa pedidos e gera texto criativo. |
| nv-mistralai/mistral-nemo-12b-instruct | 128k tokens | Modelo de linguagem avançado para raciocínio, código, tarefas multilíngues; roda em uma única GPU.|
| mistralai/mamba-codestral-7b-v0.1 | 256k tokens | Modelo para escrita e interação com código em múltiplas linguagens e tarefas.|
| microsoft/phi-3-mini-128k-instruct | 128K tokens | LLM leve, de última geração, com habilidades de lógica e matemática.|
| microsoft/phi-3-mini-4k-instruct | 4.096 tokens | LLM leve, de última geração, com habilidades de lógica e matemática.|
| microsoft/phi-3-small-8k-instruct | 8.192 tokens | LLM leve, de última geração, com habilidades de lógica e matemática.|
| microsoft/phi-3-small-128k-instruct | 128K tokens | LLM leve, de última geração, com habilidades de lógica e matemática.|
| microsoft/phi-3-medium-4k-instruct | 4.096 tokens | LLM leve, de última geração, com habilidades de lógica e matemática.|
| microsoft/phi-3-medium-128k-instruct | 128K tokens | LLM leve, de última geração, com habilidades de lógica e matemática.|
| microsoft/phi-3.5-mini-instruct | 128K tokens | LLM multilíngue leve para aplicações de IA restritas em memória e tempo.|
| microsoft/phi-3.5-moe-instruct | 128K tokens | LLM avançada baseada em Mixture of Experts para geração eficiente de conteúdo.|
| microsoft/kosmos-2 | 1.024 tokens | Modelo multimodal revolucionário para compreender e raciocinar elementos visuais em imagens.|
| microsoft/phi-3-vision-128k-instruct | 128k tokens | Modelo multimodal aberto de ponta para raciocínio de alta qualidade a partir de imagens.|
| microsoft/phi-3.5-vision-instruct | 128k tokens | Modelo multimodal aberto de ponta para raciocínio de alta qualidade a partir de imagens.|
| databricks/dbrx-instruct | 12k tokens | LLM de uso geral com desempenho no estado da arte para linguagem, programação e RAG.|
| snowflake/arctic | 1.024 tokens | Inferência eficiente para aplicações empresariais focadas em SQL e programação.|
| aisingapore/sea-lion-7b-instruct | 4.096 tokens | LLM para representação e diversidade linguística e cultural do sudeste asiático.|
| ibm/granite-8b-code-instruct | 4.096 tokens | LLM para programação: geração, explicação e diálogo multi-turn de código.|
| ibm/granite-34b-code-instruct | 8.192 tokens | LLM para programação: geração, explicação e diálogo multi-turn de código.|
| ibm/granite-3.0-8b-instruct | 4.096 tokens | Pequeno modelo avançado, com suporte a RAG, sumário, classificação, código e IA agentica.|
| ibm/granite-3.0-3b-a800m-instruct | 4.096 tokens | Modelo Mixture of Experts eficiente para RAG, sumário, extração de entidades, classificação.|
| mediatek/breeze-7b-instruct | 4.096 tokens | Gera dados sintéticos diversos.|
| upstage/solar-10.7b-instruct | 4.096 tokens | Excelente em tarefas de PLN, especialmente seguir instruções, raciocínio e matemática.|
| writer/palmyra-med-70b-32k | 32k tokens | LLM líder para respostas médicas precisas e contextuais.|
| writer/palmyra-med-70b | 32k tokens | LLM líder para respostas médicas precisas e contextuais.|
| writer/palmyra-fin-70b-32k | 32k tokens | LLM especializada em análise financeira, relatórios e processamento de dados.|
| 01-ai/yi-large | 32k tokens | Poderoso para inglês e chinês, incluindo chatbot e escrita criativa.|
| deepseek-ai/deepseek-coder-6.7b-instruct | 2k tokens | Modelo avançado para geração de código, autocomplete, infilling.|
| rakuten/rakutenai-7b-instruct | 1.024 tokens | LLM topo de linha, compreensão, raciocínio e geração textual.|
| rakuten/rakutenai-7b-chat | 1.024 tokens | LLM topo de linha, compreensão, raciocínio e geração textual.|
| baichuan-inc/baichuan2-13b-chat | 4.096 tokens | Suporte a chat em chinês/inglês, programação, matemática, seguir instruções, resolver quizzes.|
**Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
```bash
@@ -679,15 +513,12 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
Exemplo de uso em seu projeto CrewAI:
```python Code
llm = LLM(
model="groq/llama-3.2-90b-text-preview",
model="groq/qwen/qwen3.6-27b",
temperature=0.7
)
```
| Modelo | Janela de Contexto | Melhor Para |
|-------------------|---------------------|------------------------------------------|
| Llama 3.1 70B/8B | 131.072 tokens | Alta performance e tarefas de contexto grande|
| Llama 3.2 Série | 8.192 tokens | Tarefas gerais |
| Mixtral 8x7B | 32.768 tokens | Equilíbrio entre performance e contexto |
A Groq diferencia modelos production e preview e desativa IDs regularmente. Consulte o [catálogo de modelos da Groq](https://console.groq.com/docs/models) e a [página de descontinuações](https://console.groq.com/docs/deprecations) antes de escolher um modelo para produção.
**Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
```bash
@@ -769,11 +600,12 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
Exemplo de uso em seu projeto CrewAI:
```python Code
llm = LLM(
model="llama-3.1-sonar-large-128k-online",
base_url="https://api.perplexity.ai/"
model="perplexity/sonar-pro"
)
```
Consulte o [catálogo de modelos da Perplexity](https://docs.perplexity.ai/getting-started/models) e o [changelog](https://docs.perplexity.ai/docs/resources/changelog) para obter IDs atuais e avisos de descontinuação.
**Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
```bash
uv add 'crewai[litellm]'
@@ -809,17 +641,12 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
Exemplo de uso em seu projeto CrewAI:
```python Code
llm = LLM(
model="sambanova/Meta-Llama-3.1-8B-Instruct",
model="sambanova/Meta-Llama-3.3-70B-Instruct",
temperature=0.7
)
```
| Modelo | Janela de Contexto | Melhor Para |
|-------------------|---------------------------|----------------------------------------------|
| Llama 3.1 70B/8B | Até 131.072 tokens | Alto desempenho, tarefas com grande contexto |
| Llama 3.1 405B | 8.192 tokens | Desempenho e qualidade de saída elevada |
| Llama 3.2 Série | 8.192 tokens | Tarefas gerais e multimodais |
| Llama 3.3 70B | Até 131.072 tokens | Desempenho e qualidade de saída elevada |
| Família Qwen2 | 8.192 tokens | Desempenho e qualidade de saída elevada |
Os modelos hospedados no SambaNova Cloud podem mudar independentemente do CrewAI. Consulte o [endpoint de modelos](https://docs.sambanova.ai/docs/api-reference/models/get-environments-available-model-list-metadata) e o [guia de descontinuação](https://docs.sambanova.ai/docs/en/models/deprecations) antes de implantar.
**Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
```bash
@@ -837,7 +664,7 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
Exemplo de uso em seu projeto CrewAI:
```python Code
llm = LLM(
model="cerebras/llama3.1-70b",
model="cerebras/gpt-oss-120b",
temperature=0.7,
max_tokens=8192
)
@@ -851,6 +678,8 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
- Suporte a longas janelas de contexto
</Info>
Consulte o [catálogo de modelos Cerebras](https://inference-docs.cerebras.ai/models/overview) e os [avisos de descontinuação](https://inference-docs.cerebras.ai/support/deprecation) para obter os IDs atuais dos endpoints públicos.
**Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
```bash
uv add 'crewai[litellm]'
@@ -898,7 +727,7 @@ O CrewAI suporta respostas em streaming de LLMs, permitindo que sua aplicação
# Crie um LLM com streaming ativado
llm = LLM(
model="openai/gpt-4o",
model="openai/gpt-5.6-terra",
stream=True # Ativar streaming
)
```
@@ -935,6 +764,8 @@ O CrewAI suporta respostas em streaming de LLMs, permitindo que sua aplicação
O CrewAI suporta respostas estruturadas de LLMs permitindo que você defina um `response_format` usando um modelo Pydantic. Isso permite que o framework automaticamente faça o parsing e valide a saída, facilitando a integração da resposta em sua aplicação sem pós-processamento manual.
O suporte a saídas estruturadas varia de acordo com o provedor e o modelo. Teste o modelo escolhido antes de depender de respostas estruturadas em produção.
Por exemplo, é possível definir um modelo Pydantic para representar a resposta esperada e passá-lo como `response_format` ao instanciar o LLM. O modelo será utilizado para converter a resposta do LLM em um objeto Python estruturado.
```python Code
@@ -946,7 +777,7 @@ class Dog(BaseModel):
breed: str
llm = LLM(model="gpt-4o", response_format=Dog)
llm = LLM(model="openai/gpt-5.6-terra", response_format=Dog)
response = llm.call(
"Analyze the following messages and return the name, age, and breed. "
@@ -975,8 +806,8 @@ Saiba como obter o máximo da configuração do seu LLM:
# 3. Divisão de tarefas para grandes contextos
llm = LLM(
model="gpt-4",
max_tokens=4000, # Limitar tamanho da resposta
model="openai/gpt-5.6-terra",
max_completion_tokens=4000, # Limitar tamanho da resposta
)
```
@@ -1000,15 +831,14 @@ Saiba como obter o máximo da configuração do seu LLM:
```python
# Configure o modelo com as opções certas
llm = LLM(
model="openai/gpt-4-turbo-preview",
temperature=0.7, # Ajuste conforme a tarefa
max_tokens=4096, # Defina conforme a necessidade da saída
timeout=300 # Timeout maior para tarefas complexas
model="openai/gpt-5.6-terra",
reasoning_effort="medium",
max_completion_tokens=4096,
timeout=300
)
```
<Tip>
- Temperaturas baixas (0.1 a 0.3) para respostas factuais
- Temperaturas altas (0.7 a 0.9) para tarefas criativas
Use os controles compatíveis com o modelo escolhido. Dependendo do provedor, isso pode ser `temperature`, um nível de reasoning ou thinking, ou instruções no prompt que definam o estilo e a variabilidade desejados.
</Tip>
</Step>

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -24,7 +24,25 @@ O `NL2SQLTool` opera em **modo somente leitura por padrão**. Apenas os seguinte
Qualquer tentativa de executar uma operação de escrita (`INSERT`, `UPDATE`, `DELETE`, `DROP`, `CREATE`, `ALTER`, `TRUNCATE`, etc.) resultará em erro, a menos que o DML seja habilitado explicitamente.
Consultas com múltiplas instruções contendo ponto e vírgula (ex.: `SELECT 1; DROP TABLE users`) também são bloqueadas no modo somente leitura para prevenir ataques de injeção.
O modo somente leitura também bloqueia os caminhos indiretos para uma escrita:
| Bloqueado no modo somente leitura | Exemplo |
| --- | --- |
| Consultas com múltiplas instruções | `SELECT 1; DROP TABLE users` |
| CTEs de escrita, incluindo a forma `MATERIALIZED` | `WITH d AS MATERIALIZED (DELETE FROM users RETURNING *) SELECT * FROM d` |
| Uma escrita após uma CTE | `WITH d AS (SELECT 1) DELETE FROM users` |
| `EXPLAIN ANALYZE`, que executa seu argumento | `EXPLAIN ANALYZE DELETE FROM users` |
| Escrita no sistema de arquivos do servidor de banco de dados | `SELECT * FROM users INTO OUTFILE '/var/www/shell.php'` |
| Funções que alcançam o sistema de arquivos do servidor ou abrem uma nova conexão | `SELECT pg_read_file('/etc/passwd')`, `dblink_exec(...)` |
| Uma instrução `WITH` que não pode ser confirmada como somente leitura | `WITH d AS DELETE FROM users` |
As instruções são analisadas com literais de texto e comentários mascarados, de modo que uma palavra-chave escondida em um literal não é confundida com um comando (`SELECT 'DROP TABLE users'` é permitido) e um comentário colocado entre palavras-chave não esconde nenhum (`EXPLAIN /*x*/ ANALYZE DELETE ...` é bloqueado). Um ponto e vírgula dentro de um literal não conta como separador de instruções, portanto `SELECT ';'` é uma única instrução válida.
No modo somente leitura, a ferramenta também marca a transação como `SET TRANSACTION READ ONLY`, de forma que PostgreSQL e MySQL rejeitam escritas no próprio banco de dados, independentemente de como a instrução foi escrita. Backends sem essa sintaxe (SQLite, SQL Server, Snowflake) registram uma mensagem de depuração e voltam a depender apenas da validação de instruções — mais um motivo para confiar em um papel somente leitura em vez da análise textual.
<Warning>
As verificações internas de somente leitura são defesa em profundidade, não uma fronteira completa. Elas inspecionam o texto da instrução, e SQL é específico de cada banco: uma instrução que começa com `SELECT` ainda pode alcançar o sistema de arquivos do servidor (`SELECT ... INTO OUTFILE`, `pg_read_file()`) ou chamar uma função com efeitos colaterais. Os caminhos conhecidos são bloqueados explicitamente, mas o único controle completo são os privilégios concedidos em `db_uri`. **Aponte a ferramenta para um papel de banco de dados somente leitura e com privilégio mínimo.**
</Warning>
### Habilitando Operações de Escrita

View File

@@ -13,8 +13,7 @@ mode: "wide"
O FileReadTool representa conceitualmente um conjunto de funcionalidades dentro do pacote crewai_tools voltadas para facilitar a leitura e a recuperação de conteúdo de arquivos.
Esse conjunto inclui ferramentas para processar arquivos de texto em lote, ler arquivos de configuração em tempo de execução e importar dados para análise.
Ele suporta uma variedade de formatos de arquivo baseados em texto, como `.txt`, `.csv`, `.json` e outros. Dependendo do tipo de arquivo, o conjunto oferece funcionalidades especializadas,
como converter conteúdo JSON em um dicionário Python para facilitar o uso.
Ele suporta uma variedade de formatos de arquivo baseados em texto, como `.txt`, `.csv`, `.json` e outros. O conteúdo é sempre retornado como texto simples.
## Instalação

View File

@@ -32,7 +32,11 @@ from crewai_tools import FileWriterTool
file_writer_tool = FileWriterTool()
# Escreva conteúdo em um arquivo em um diretório especificado
result = file_writer_tool._run('example.txt', 'This is a test content.', 'test_directory')
result = file_writer_tool.run(
filename='example.txt',
content='This is a test content.',
directory='test_directory',
)
print(result)
```

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ class ContentApprovalFlow(Flow):
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| الترويسة | الوصف |
|--------|-------------|
| `X-CrewAI-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
| `X-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
#### التحقق

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ class ContentApprovalFlow(Flow):
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| الترويسة | الوصف |
|--------|-------------|
| `X-CrewAI-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
| `X-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
#### التحقق

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ class ContentApprovalFlow(Flow):
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| الترويسة | الوصف |
|--------|-------------|
| `X-CrewAI-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
| `X-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
#### التحقق

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ class ContentApprovalFlow(Flow):
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| الترويسة | الوصف |
|--------|-------------|
| `X-CrewAI-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
| `X-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
#### التحقق

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ class ContentApprovalFlow(Flow):
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| الترويسة | الوصف |
|--------|-------------|
| `X-CrewAI-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
| `X-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
#### التحقق

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ class ContentApprovalFlow(Flow):
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| الترويسة | الوصف |
|--------|-------------|
| `X-CrewAI-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
| `X-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
#### التحقق

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ class ContentApprovalFlow(Flow):
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| الترويسة | الوصف |
|--------|-------------|
| `X-CrewAI-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
| `X-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
#### التحقق

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ class ContentApprovalFlow(Flow):
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| الترويسة | الوصف |
|--------|-------------|
| `X-CrewAI-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
| `X-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
#### التحقق

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ class ContentApprovalFlow(Flow):
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| الترويسة | الوصف |
|--------|-------------|
| `X-CrewAI-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
| `X-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
#### التحقق

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ class ContentApprovalFlow(Flow):
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| الترويسة | الوصف |
|--------|-------------|
| `X-CrewAI-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
| `X-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
#### التحقق

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ class ContentApprovalFlow(Flow):
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| الترويسة | الوصف |
|--------|-------------|
| `X-CrewAI-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
| `X-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
#### التحقق

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ class ContentApprovalFlow(Flow):
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| الترويسة | الوصف |
|--------|-------------|
| `X-CrewAI-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
| `X-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
#### التحقق

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ class ContentApprovalFlow(Flow):
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| الترويسة | الوصف |
|--------|-------------|
| `X-CrewAI-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
| `X-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
#### التحقق

View File

@@ -387,26 +387,27 @@ All webhooks receive a JSON payload with this structure:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Each webhook request includes these headers:
| Header | Description |
|--------|-------------|
| `X-CrewAI-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Unix timestamp when the request was signed |
| `X-Signature` | HMAC-SHA256 signature: `sha256=<hex_digest>` |
| `X-Timestamp` | Unix timestamp when the request was signed |
#### Verification

View File

@@ -387,26 +387,27 @@ Flow가 인간 피드백을 위해 일시 중지되면, 요청 데이터를 자
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "이 기사의 게시를 검토해 주세요.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| 헤더 | 설명 |
|------|------|
| `X-CrewAI-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
| `X-Signature` | HMAC-SHA256 서명: `sha256=<hex_digest>` |
| `X-Timestamp` | 요청이 서명된 Unix 타임스탬프 |
#### 검증

View File

@@ -387,26 +387,27 @@ Todos os webhooks recebem um payload JSON com esta estrutura:
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Por favor, revise este artigo para publicação.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Cada requisição de webhook inclui estes headers:
| Header | Descrição |
|--------|-----------|
| `X-CrewAI-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
| `X-Signature` | Assinatura HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | Timestamp Unix de quando a requisição foi assinada |
#### Verificação

View File

@@ -387,26 +387,27 @@ class ContentApprovalFlow(Flow):
```json
{
"event_type": "new_request",
"id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"output": "Content to review...",
"emit": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
"event": "new_request",
"request": {
"id": "550e8400-e29b-41d4-a716-446655440000",
"flow_id": "flow_abc123",
"method_name": "review_article",
"message": "Please review this article for publication.",
"emit_options": ["approved", "rejected", "request_changes"],
"state": {
"article_id": 12345,
"author": "john@example.com",
"category": "technology"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z"
},
"metadata": {},
"created_at": "2026-01-14T12:00:00Z",
"callback_url": "https://app.crewai.com/crewai_plus/api/v1/human_feedback_requests/{id}/respond?token={response_token}",
"response_token": "secure-token-string",
"deployment_id": 456,
"deployment_name": "Content Review Flow",
"organization_id": 789,
"deployment": {
"id": 456,
"name": "Content Review Flow",
"organization_id": 789
},
"callback_url": "https://api.crewai.com/...",
"assigned_to_email": "reviewer@company.com"
}
```
@@ -444,8 +445,8 @@ Content-Type: application/json
| الترويسة | الوصف |
|--------|-------------|
| `X-CrewAI-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-CrewAI-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
| `X-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
| `X-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
#### التحقق

Some files were not shown because too many files have changed in this diff Show More