flw-studio 0.1.0__tar.gz

flw_studio-0.1.0/CHANGELOG.md

@@ -0,0 +1,331 @@
+# Changelog
+
+All notable changes to **agentic-flow** are recorded here.
+
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
+the project aims to follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-06-21
+
+Initial release: declare agents (system prompt + tools) in YAML and run them as an
+orchestrated **graph** over one shared `Store`, on Gemini (default) or Anthropic.
+
+### Added
+
+**The flow graph**
+- **Graph IR** (`agentic_flow/graph.py`): a `Node` (one body per kind —
+  `agent`/`tool`/`human`) plus three `Edge` kinds — **static** (`{from, to}`),
+  **conditional** (`{from, to, when[, else]}`; a back-edge is a loop), and
+  **model-driven** (`{from, route: {by, to}}`). `Graph` bundles a `nodes` dict + an
+  `edges` **tuple** (declaration order is load-bearing for determinism) + an `entry`
+  + an `Authority`. First-violation `validate()` with stable `GraphError` codes
+  (reachability, dead-end, reserved id, route-target-is-a-node, undeclared refs,
+  zero-visits, …), `cycles()`, and `render_graph` (the `--dry-run` view).
+  `END = "__end__"` is the terminal sentinel.
+- **Two authoring surfaces, one engine** (`agentic_flow/loader.py`):
+  `build_program(config, registry)` → a validated `Graph` + the agent map. A
+  `graph:` block is the explicit node/edge surface; a `pipeline:` block is linear
+  **lowering sugar** — `when:` → a `cond:` control node + conditional edges, `loop:`
+  → the body inlined + a `loopcheck:` control node with a `max_visits`-bounded
+  back-edge (do-while semantics, including a graceful cap-exit so a non-converging
+  loop *continues* rather than failing), `human:` → a pause node. Synthetic control
+  nodes are excluded from `max_steps`. One `LoaderError` family wraps name/shape +
+  topology errors.
+- **Executable `subgraph:` nodes — inlined at load** (`loader.py`; closes
+  known-issue #2): a `graph:` node may declare a reusable nested graph as a
+  `subgraph:` body (its own `entry`/`nodes`/`edges`). `_inline_subgraphs` splices it
+  into one flat graph at load — like `pipeline:` lowering — with prefix-qualified ids
+  `<callsite>/<inner>`, so **no `SubgraphBody` reaches the runtime**. The seam rewires:
+  an edge *into* the node retargets to the inner entry; an inner edge to the inner
+  `__end__` folds to a minted `<callsite>/__exit__` anchor that carries the node's
+  original out-edges (any kind), re-converging on the parent continuation. The flat
+  frontier checkpoints at every inner node, so **a crash resumes inside the subgraph**;
+  nested subgraphs compose prefixes (`outer/inner/x`) and the same block at two call
+  sites gets two prefixes (no id clash). Subgraphs share the one run `Store` (a
+  deliberate difference from test_flow); a `subgraph:` node that also sets `output:` is
+  a `LoaderError`. Validates with `allow_synthetic=True`; a hand-authored `/` id stays
+  `RESERVED_ID`; `render_graph`/`--dry-run` show the qualified ids.
+- **Node `output_schema` validation** (`agentic_flow/schema.py`, `graph.py`, `loader.py`,
+  `runtime.py`; feature 0004): a `graph:` node may declare an `output_schema` — a
+  validation contract on whatever it produces. The runtime checks the node's output
+  against it **just before the reducer merge**; a mismatch is a terminal
+  `NodeOutputError` (`status:"failed"`) naming the node and the violation, so a bad
+  shape never enters shared state. The validator (`schema.validate_value(schema, value)
+  -> list[str]`) is a small, **dependency-free** JSON-Schema subset — `type`
+  (object/array/string/number/integer/boolean/null), object `properties` + `required`,
+  array `items`, `enum` — with path + expected/got messages (no `jsonschema` dep). It is
+  **validation-only**: an agent node still needs its own `output_schema` to emit a
+  `dict` (an agent returning text where an object is required fails with a hint). A node
+  without `output_schema` runs unchanged; a malformed schema is a `LoaderError` at load.
+
+**The data plane**
+- **Channels + reducers** (`agentic_flow/store.py`,
+  **[ADR 0002](docs/adr/0002-channels-and-reducers.md)**): each state key is a
+  `Channel` — a value, a monotonic `version`, and a `Reducer` (`last_write` /
+  `append` / `merge` / `numeric_add` / `set_union`). `Store` is the `MutableMapping`
+  over those channels (templating/tools ride the same seam) and composes the
+  `MessageLog` + `TodoBoard`. Reducers **fail loud** (`ReducerTypeError` *before*
+  mutating); selection is author-only. The snapshot persists the reducer name and
+  re-coerces on restore; `from_dict` rejects an unknown version
+  (`UnsupportedSnapshotVersion`). An all-`last_write` store is a plain flat
+  last-writer-wins state — the common case (a `pipeline:` declares no reducer).
+- **`channels:` YAML surface + `add_messages` reducer** (`store.py`, `loader.py`,
+  `program.py`; closes known-issue #3): a `graph:` author declares a channel's
+  reducer in a top-level `channels:` block (`name: { reducer: X }` or shorthand
+  `name: X`), so two nodes can write the same `output:` and the reducer accumulates
+  instead of clobbering. The loader checks each reducer against `REDUCERS` (unknown
+  → a clear `LoaderError`) and flags a node output to an undeclared channel as
+  `CHANNEL_UNDECLARED` before the run; the `Orchestrator` applies the declared
+  reducers to the run's `Store` (via `Store.declare`) before execution. New
+  `add_messages` reducer: accumulate a message transcript by `id` — append, replace
+  on id match, assign an id when absent, and delete via a JSON-safe
+  `RemoveMessage(id)` sentinel. `pipeline:` stays all-`last_write`.
+- **Shared transcript on agent nodes — `emit:`** (`graph.py`, `loader.py`,
+  `runtime.py`; feature 0006, satisfies the 0001 Non-Goal): a `graph:` agent node may
+  declare `emit: <channel>`. After the agent answers, the runtime appends **one** turn
+  `{id, sender, content}` to that channel — at **commit 1**, right after the `output:`
+  write and **before** the `completed` bump + boundary save, so a completed node never
+  re-emits on resume. `content` is the answer as-returned (a `str`, or a `dict` for an
+  `output_schema` agent); the channel's `add_messages` reducer mints the `id`. `emit` is
+  independent of `output:` (a node may set either, both, or neither) and does not affect
+  `output_schema` validation. The loader gates `emit:` to a channel declared `add_messages`
+  in the `channels:` block (an undeclared channel, or a non-`add_messages` reducer, is a
+  `LoaderError` naming the node + channel). A later node **reads** the transcript through
+  ordinary `{channel}` templating (no formatter, no `messages: shared` auto-channel) —
+  collaboration over a shared blackboard, alongside the exactly-once push log. `graph:`-only
+  (a `pipeline:` step has no `emit`).
+- **Load-time input template-reference check** (`graph.py`, `templating.py`; feature
+  0007): the **symmetric** counterpart to the `output:` check. In `channels:` mode the
+  declared block is the *complete* channel namespace, so every `{key}` a node (or a
+  conditional edge) **reads** must name a declared channel — a typo'd `{notez}` is now a
+  load-time `LoaderError` (new stable `GraphError` code `INPUT_REF_UNDECLARED`, naming
+  node/edge + template + missing ref) instead of a mid-run `KeyError` from
+  `templating.render`. The templates scanned are an agent node's `input:`, a tool node's
+  **string** `args:` values, and a conditional edge's `when:` condition. A new pure
+  `templating.refs(template) -> set[str]` extracts the **root** channel ref of each `{...}`
+  field (`{review[score]}` → `review`); `Graph.validate` reuses it (its one package import
+  is this leaf). It is a **sound membership** check (it permits reading a channel a *later*
+  node writes on a back-edge), **not** a runtime `input_schema` and **not** an ordering
+  analysis — so 0004's deferred input side is addressed as **reachability**, not shape. The
+  author rule: **declare every channel you read** (a run-seed key or a `state_write` runtime
+  key a template reads must also be declared, e.g. `seed: last_write`; no implicit
+  exemption). Absent `channels:`, there is no input-ref check (the flat-`last_write` default
+  is preserved); the check runs **after** `subgraph:` inlining (inner refs are the bare
+  channel names).
+
+**Secrets — referenced, late-resolved, never checkpointed**
+- **The secrets seam** (`agentic_flow/secrets.py` + `loader.py` / `store.py` /
+  `context.py` / `tools/core.py` / `program.py` / `providers/` / `tools/mcp.py`;
+  feature 0008, **[ADR 0003](docs/adr/0003-secrets-and-config.md)**): a credential is
+  **named** in YAML, never embedded. A top-level `secrets:` block maps a local name to a
+  pluggable backend (`{provider: env, var: X}` / `{provider: file, path: P}` / shorthand
+  `name: VAR`; `provider:` defaults to `env`). The new `secrets.py` leaf is stdlib-only —
+  `Secret` (masked, `.reveal()`-only, **not** JSON-serializable so a stray one fails
+  loud), the pluggable `SecretProvider` registry (`register_secret_provider` /
+  `get_secret_provider`; dependency-free `env` / `file` built-ins), the lazy-caching
+  `SecretResolver` (a backend `fetch` runs at most once per name), and the pure ref
+  helpers (`is_secret_ref` / `interpolate_env`). The run's **one** resolver is built once
+  in `build_program` over an injectable `environ` and **rides the `Store` off-channel**
+  (the `known_agents` pattern) — `snapshot()` never serializes it, so a credential
+  *structurally cannot* enter a checkpoint. It is `.reveal()`-ed only at point-of-use:
+  a provider's `api_key: {secret: name}` (revealed at lazy `.client` construction;
+  keyless = unchanged env path), an MCP server's `env:` / `headers:` values
+  (`{secret:}` or `${VAR}` / `${VAR:-default}`, resolved at connect — `mcp.py` stays pure
+  of secrets), or a tool body's `ctx.secrets.get(name).reveal()` (plus a framework-injected
+  `secrets` param, kept out of the model schema). `${VAR}` interpolation is a **separate**
+  pass scoped to credential fields only — never `{key}` state templating. A typo'd
+  `{secret: nope}` or unknown `provider:` is a `LoaderError` **before** the run; a missing
+  var/file or an unset `${VAR}` with no default is a `SecretError`. A `vault`/`aws`/cloud
+  backend is a registry entry away (lazy-imports its SDK inside `fetch`) — seam-ready,
+  shipped behind a `verify-real-deps` gate (see [known-issues.md](docs/known-issues.md)).
+  A caller-**injected** provider (`build_program(providers=…)`, the test/programmatic seam)
+  **wins** over keyed construction: a `{secret:}` `api_key` ref is still validated, but the
+  injected instance is used as-is (no fetch) — so an offline build with a `{secret:}` key
+  needs no real credential. The `api_key: {secret:}` agent surface is exercised offline by
+  `tests/test_secrets.py`; `examples/secrets_demo` shows the tool-side `ctx.secrets` read.
+
+**The scheduler & durability**
+- **The flat-frontier scheduler** (`agentic_flow/runtime.py`,
+  **[ADR 0001](docs/adr/0001-graph-cursor-resume.md)**): `run` / `resume` walk a
+  frontier of ready nodes. The per-node commit order is load-bearing — write → bump
+  `completed` → remove from frontier → resolve out-edges → **save** — and a
+  checkpoint is written at **every node boundary**, so a crash resumes at the last
+  completed node, inside loops/branches too (**at-least-once** — a crash before
+  `save` re-runs one node). `pick_ready` re-evaluates join readiness; terminal
+  failures write a `status:"failed"` record before propagating; a tool node runs
+  under the tool's retry policy.
+- **The graph cursor** (`agentic_flow/cursor_format.py`): `CheckpointRecord` —
+  `{status, error, channels, versions, completed, frontier, edge_log, pending,
+  budget, replans, snapshot}`. The `frontier + completed` *is* the serialized
+  program counter; resume restores it verbatim. `is_completed` is structural;
+  `from_dict` guards the version and rejects a truncated record with a typed error.
+- **Durable checkpointing** (`agentic_flow/checkpoint.py`, stdlib-only): a
+  `Checkpointer` ABC — `save` / `load` / `delete` over an **opaque JSON record**
+  keyed by `run_id` — with `InMemoryCheckpointer` and `JsonFileCheckpointer` built
+  in, plus a naming registry (`register_checkpointer` / `get_checkpointer`, `memory`
+  / `json`).
+- **Human-in-the-loop**: a `human:` node renders its prompt, tracks a todo
+  (`in_progress` → `blocked` → `done`), checkpoints a `pending` marker, and raises
+  `NodePaused`. `resume(human_input=…)` injects the answer and continues;
+  `HumanInputRequired` signals a pending pause with no answer.
+
+**Model-driven flow — the authority spectrum**
+- The human authors the graph; the author declares how much authority the model has,
+  and the model only ever composes from the author's declared vocabulary.
+  - **Route (L1)** — a `route:` edge invokes a router (`output_schema` `{next,
+    reason}`) agent that picks the next node from the declared `to:` set. The pick is
+    validated, recorded in `edge_log`, and **replayed on resume**; an out-of-set pick
+    is fail-loud (`RouteOutOfSet`, terminal).
+  - **Replan (L2)** (`agentic_flow/authority.py`) — an `authority.replan:` policy
+    (`{by, when, allow, powers, max_replans}`) fires at a node boundary only when the
+    guard trips (**zero planner cost** otherwise). The planner proposes a batch of
+    edits to the not-yet-run subgraph; `validate_replan` checks the **folded batch**
+    atomically (five gates — vocabulary, powers, past-immutable, referential,
+    reachability) and keeps the un-amended graph on rejection. The accepted delta
+    persists in the cursor and resume replays it by a pure fold — **durable replan**.
+
+**Agents & tools**
+- **`Agent`** — a system prompt + tools + a hand-written tool-use loop, bounded by
+  `MAX_STEPS`. Surfaces every tool call/result through `on_event`. **Structured
+  output** via `output_schema` (`additionalProperties: false` injected; malformed
+  JSON raises `OutputParseError` and is retried). **Agents as tools** — delegate via
+  an `agents:` list; sub-agents share the same `Store`; cycles bounded by
+  `MAX_STEPS`. **Adaptive thinking** on by default (Anthropic).
+- **`Tool` + `@tool`** — derive a model-callable tool's JSON Schema from a function's
+  type hints and Google-style docstring; resolve stringized hints; hide injected
+  `state`/`ctx` params. `Tool.invoke(args, ctx)` is the one home for calling a tool.
+  `ToolRegistry` has named groups; a YAML agent's `tools:` list takes individual
+  names or a group name that expands.
+- **MCP servers as a tool group** (`agentic_flow/tools/mcp.py`): a top-level `mcp:`
+  block maps a server name to a `{command: […]}` (stdio) or `{url: …}` (HTTP/SSE)
+  spec; the framework connects each server through an **injected client factory**
+  (`build_program(..., mcp_client_factory=connect_mcp)`, threaded through
+  `Orchestrator.from_yaml`/`from_config`), lists its tools, and registers each under
+  a group named for the server — so `tools: [<server>]` grants them via the existing
+  `resolve()` path. The server-**declared** JSON schema is the `Tool.parameters`
+  verbatim (contract data across a process boundary, not Python-derived); a
+  server-side error becomes a tool-error string, not a crash. A name collision →
+  `LoaderError` naming the server; a connect/list failure or missing SDK → `McpError`
+  naming the server. The MCP SDK is an **optional** `mcp` extra — `connect_mcp`
+  lazy-imports it only when called, so `import agentic_flow` and the whole offline
+  suite run with no SDK installed (tests inject a fake factory; new `tests/test_mcp.py`).
+- **Coordination built-ins**: `state` (`state_write`/`state_read`/`state_keys`),
+  `messaging` (`send_message`/`read_messages`), and the `todos` board. **Exactly-once
+  push delivery** of messages and assigned todos into a recipient's prompt.
+- **`Context`** (`agentic_flow/context.py`) — the shared store + caller name handed
+  to an injected tool.
+- **`RetryPolicy` + `run_with_retry`** — configurable attempts with backoff.
+- **Capacity & timeout limits** (`agentic_flow/limits.py`): a `limits:` block at two
+  scopes — **agent** (`max_steps`, `token_budget`, `timeout`, `call_timeout`) and
+  **run** (top-level `max_steps`, `timeout`). Breaches raise dedicated, non-retried
+  exceptions.
+
+**Providers**
+- Pluggable `Provider` seam (`start` / `complete` / `add_assistant` /
+  `add_tool_results`) with normalized `Completion` / `ToolCall` / `ToolResult`.
+  **Gemini** (`google-genai`, default `gemini-3.5-flash`) and **Anthropic**
+  (`anthropic`, default `claude-opus-4-8`; thinking blocks preserved across turns).
+  Lazy SDK imports keep the pure logic testable without a key; mixed-provider runs
+  share one `Store`.
+
+**Facade, CLI & observability**
+- **`Orchestrator` facade** (`agentic_flow/program.py`): the ergonomic
+  `from_yaml` / `from_config` / `run` / `resume` surface over `build_program` +
+  `runtime`. `run`/`resume` raise `NodePaused` / `HumanInputRequired` /
+  `RuntimeFailure`; run-scope `max_steps`/`timeout` come from a `limits:` block.
+- **`agentic-flow` CLI** (`agentic_flow/cli.py`): run a pipeline, `--tools MODULE`,
+  `--set KEY=VALUE`, `--dry-run` (renders the graph — nodes, edges grouped by source
+  with kind annotations and `(back-edge)` flags, an authority footer),
+  `--checkpoint SPEC` / `--run-id` / `--resume` / `--human-input*`. **Exit codes:**
+  `0` completed, `1` error, `2` paused (printing a copy-pasteable resume command). A
+  `human:` run without `--checkpoint` is rejected up front.
+- **`on_event` is the single observability seam.** A `console_tracer()` renderer
+  (`agentic_flow/console.py`), an `event_logger()` → `logging` adapter
+  (`agentic_flow/log.py`), and an `EventBus` (`agentic_flow/events.py`, a pub/sub
+  fan-out with per-subscriber filtering, `Subscription` handles, error isolation, a
+  thread-safe `stream()`, and `run_in_background()`). Taxonomy: `node_start` /
+  `node_end` / `checkpoint` / `human` / `route` / `replan` / `replan_rejected`, plus
+  agent-level `tool_call` / `tool_result` / `retry` / `messages_delivered`.
+- **Durable execution trace** — a layer-2 extension over the `on_event` seam
+  (feature 0009). Two **additive** core events — `node_input` (a node's rendered
+  prompt / args) and `node_error` (a terminal failure's detail) — make full per-node
+  I/O observable without changing existing behavior. The consumer lives **outside**
+  the package, in a reference tree `extensions/observability/` (like `examples/`: on
+  `sys.path`, **not in the core wheel**) that imports core one-way: `TraceSink(run_id,
+  dir)` persists every event to append-only `<dir>/<run_id>.jsonl` (swallow-on-error,
+  so it never breaks the run), `summarize(run_id, dir)` folds it into one `NodeTrace`
+  per node execution (input / output / status / `duration_ms`, timed in layer 2), and
+  `python -m extensions.observability <run_id> --dir D` renders the per-node table
+  (unknown run id → stderr + non-zero). **No** vendor export (LangSmith / OTel) and
+  **no** history / time-travel — local JSONL only.
+- **Visual pipeline studio** (`ui/`): a no-build static web app that renders a
+  pipeline YAML as a flowchart and round-trips it to/from YAML (authoring only).
+
+**Package structure**
+- **Core/layer-2 split** (`agentic_flow/core/`; feature 0010,
+  **[ADR 0004](docs/adr/0004-core-and-layer2-boundary.md)**): restructured the
+  package — the engine moved to `agentic_flow.core` (layers 0+1: `graph` / `store` /
+  `agent` / `runtime` / `authority` / `cursor_format` / `checkpoint` / `tools` /
+  `providers` + the pure leaves `schema` / `templating` / `secrets` / `events` /
+  `limits` / `retry`); layer-2 consumers (`loader` / `pipeline` / `console` / `log` /
+  `program` / `cli`) stay at the top level and consume the engine through the six
+  seams. One-way layering (`core/` never imports upward) is enforced by
+  `tests/test_layering.py`. **Public `from agentic_flow import …` API unchanged**
+  (the facade re-exports from the new paths); deep submodule paths moved
+  (`agentic_flow.runtime` → `agentic_flow.core.runtime`). The `builtins.py` shim was
+  removed. A pure relocation — no behavior change.
+
+**Docs, examples & tests**
+- Project documentation under [`docs/`](docs/): an architecture map
+  ([ARCHITECTURE.md](docs/ARCHITECTURE.md)), a feature catalog
+  ([FEATURES.md](docs/FEATURES.md)), an internals walkthrough
+  ([INTERNALS.md](docs/INTERNALS.md)), two ADRs
+  ([0001](docs/adr/0001-graph-cursor-resume.md) graph-cursor resume,
+  [0002](docs/adr/0002-channels-and-reducers.md) channels & reducers), and
+  [known-issues.md](docs/known-issues.md). This changelog.
+- Worked examples — a 14-step ladder under [`examples/`](examples/) (see
+  [`examples/README.md`](examples/README.md)), each a single concept meant to be read in
+  order: `quickstart` (one agent/tool/step, plus `limits:`), `structured_output`,
+  `tool_steps`, `shared_state` (fan-out → fan-in over one `Store`, plus a `retry` aside),
+  `refine_loop` (a loop + conditional), `approval` (offline human gate, pause→resume),
+  `graph_branch` (the native `graph:` surface — hand-authored nodes/edges whose review
+  verdict branches to a `publish`/`flag` terminal), `router` (a model-driven `route:` edge
+  — an agent picks the next node), `subgraph_intake` (offline — a reusable `subgraph:`
+  inlined at load, `parse → validate → normalize`), `delegation` (agent-as-tool — a lead
+  agent calls a sub-agent listed under its `agents:`), `shared_transcript` (a **shared
+  transcript** — panelists `emit:` into an `add_messages` `channels:` entry, then a
+  moderator's verdict is node-`output_schema`-validated), `team_todos` (the todo board +
+  agent-to-agent messaging, plus `run_stream.py` streaming events via an `EventBus`),
+  `secrets_demo` (offline — a tool reads a file-backed `{secret:}` via `ctx.secrets`,
+  writing only a masked result; the raw value never enters the `Store`/checkpoint),
+  `incident_replan` (replan / authority L2 — a static base graph that rewrites itself when
+  an assessor marks an incident critical), and `data_pipeline` (offline ETL, no API key).
+- Twenty-one offline test suites run in Docker (`docker compose run --rm tests`, no API
+  key): `test_units`, `test_coordination`, `test_events`, `test_graph`, `test_store`,
+  `test_runtime`, `test_route`, `test_replan`, `test_loader`, `test_lowering`,
+  `test_cli`, `test_example_replan` (drives the `incident_replan` example offline),
+  `test_channels` (declared reducers), `test_subgraph` (subgraph inlining + durable
+  resume inside a subgraph), `test_mcp` (an `mcp:` server → a tool group, via a fake
+  client), `test_node_schema` (node `output_schema` validation), `test_transcript`
+  (agent-node `emit:` → a shared transcript), `test_input_refs` (the load-time
+  template-ref check), `test_secrets` (the secrets seam — `Secret` masking, the
+  `env`/`file` backends, and the no-secret-in-the-checkpoint guarantee),
+  `test_observability` (the layer-2 trace seam — `TraceSink` → JSONL, `summarize`, the
+  `python -m extensions.observability` renderer), and `test_layering` (the core-never-
+  imports-up boundary scan + engine self-sufficiency check). The lowering suite
+  round-trips every `examples/*/pipeline.yaml`.
+
+### Known limitations
+- On Gemini, `output_schema` and tools cannot be combined on a single agent (the
+  provider raises a clear error); split into two agents or use Anthropic.
+- Agent retry re-runs already-called tools — prefer tool retry for side effects.
+- A non-`last_write` channel-declaration YAML surface is not yet wired; a `graph:`
+  author writes to `last_write` channels (the reducer machinery is fully shipped).
+- `import agentic_flow` eagerly imports the vendor SDKs, so a SDK-less import is not
+  supported (see [known-issues.md](docs/known-issues.md)).
+- Requires Python ≥ 3.10.
+
+[Unreleased]: https://github.com/ai-agent-lead/agentic-flow/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/ai-agent-lead/agentic-flow/releases/tag/v0.1.0

flw_studio-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AI Agent Lead
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

flw_studio-0.1.0/MANIFEST.in

@@ -0,0 +1,8 @@
+# Source distribution (sdist) contents. The wheel ships only `agentic_flow*`
+# (see [tool.setuptools.packages.find]); the docs/examples below travel with the
+# source tarball so a clone-free `pip download` still has the full project.
+include LICENSE CHANGELOG.md README.md
+recursive-include docs *.md
+recursive-include examples *.py *.yaml *.yml *.md *.secret *.txt
+recursive-include tests *.py
+global-exclude __pycache__/* *.py[cod] .DS_Store