di-bag 0.1.0 → 0.1.1

package/README.md

@@ -1,65 +1,35 @@
 # DI Bag
 
-Dependency injection for agentic development.
+TypeScript dependency composition and resource ownership for agentic development, LLM harnesses, and agent graphs.
 
-[Documentation](https://dany-fedorov.github.io/di-bag/) · [Quickstart](#quickstart) · [Comparison](#how-it-compares) · [Tutorial](docs/guides/tutorial.md) · [API reference](docs/guides/api-reference.md)
+[Documentation](https://dany-fedorov.github.io/di-bag/) · [Quickstart](#quickstart) · [Agent harnesses](docs/guides/agent-harnesses-and-graphs.md) · [Comparison](#how-it-compares) · [Tutorial](docs/guides/tutorial.md) · [API reference](docs/guides/api-reference.md)
 
 ## Why DI Bag?
 
-DI Bag is designed to make modular applications easier for coding agents to
-work on. Modularity is a practical context-engineering technique: clear
-feature boundaries can reduce the code and dependencies an agent needs to
-consider for a task. DI Bag is a TypeScript dependency injection library built
-around that idea—helping you define those boundaries, replace dependencies in
-tests, and check how the pieces fit together.
-
-- **[Radical modularity for agentic development](docs/guides/examples-modularity.md).**
-  Compose small features with private internals and explicit contracts. Give
-  humans and coding agents focused units to implement, replace, and test
-  independently, then check their composition together.
-- **[TypeScript-first composition](docs/guides/examples-type-checking.md).**
-  Catch missing dependencies, incompatible service contracts, and invalid
-  replacements at compile time—not just incorrect arguments at the call site.
-  Coding agents can shorten their evaluation loop by checking wiring without
-  starting the app or running integration tests.
-- **[A programmable DI layer for custom tooling](docs/guides/examples-extensibility.md).**
-  Give agents the building blocks to create the tooling your workflow needs:
-  custom inspectors, diagnostics, metadata-driven actions, and lifecycle tools.
-  Combine application-defined metadata, composable provider wrappers, and
-  configurable observers without changing your services.
+Compose ordinary TypeScript factories into reusable features. DI Bag checks
+declared dependencies, keeps module internals private, and manages resource
+creation and cleanup. Build services, tools, or graph nodes against explicit
+contracts, then replace their dependencies for tests.
+
+- **[Reusable modules with private bindings](docs/guides/examples-modularity.md).**
+  Compose independently developed features without exposing their internals.
+- **[Compile-time wiring checks](docs/guides/examples-type-checking.md).**
+  Catch missing dependencies and incompatible replacements before starting the app.
+- **[Metadata inspection without service startup](docs/guides/examples-extensibility.md).**
+  Build capability catalogs without running factories or opening clients.
 - **[Inject anything with a simple factory function](docs/guides/examples-plain-services.md).**
-  DI Bag is TypeScript-first, but injecting services is as simple as writing an
-  ordinary JavaScript function: receive dependencies and return a value.
-  Functions, class instances, configuration, clients, or promises—no decorators,
-  reflection metadata, or special base classes required.
-
-Each guide above contains three complete application examples. Lazy creation,
-configurable lifetimes, scopes, and dependency-ordered cleanup support these
-patterns; the [tutorial](docs/guides/tutorial.md) explains how.
-
-For a small graph, passing dependencies directly is often simpler. Other DI
-libraries also offer typed composition and resource management; the
-[comparison below](#how-it-compares) explains the tradeoffs.
+  Supply functions, objects, clients, or promises—no decorators or base classes.
 
 ## Install
 
-This checkout is a pre-1.0 release candidate, currently versioned `0.1.0`.
-It includes breaking API changes, so expect to review migrations when updating.
-These instructions install the current checkout without assuming an npm release
-is available. Build a local package with Node 24 and npm:
+Install [di-bag from npm](https://www.npmjs.com/package/di-bag):
 
 ```sh
-git clone https://github.com/dany-fedorov/di-bag.git
-cd di-bag
-npm ci
-npm pack
+npm install di-bag
 ```
 
-Then, from your application, install the generated archive using its local path:
-
-```sh
-npm install /path/to/di-bag/di-bag-0.1.0.tgz
-```
+The API is pre-1.0 and includes breaking changes, so review the changelog and
+migration guides when updating.
 
 The minimum supported TypeScript version is **6.0.3**; enable `strict` in your
 `tsconfig.json`. The repository checks classic TypeScript 6.0.3 and native 7.0.2.
@@ -122,8 +92,9 @@ try {
 }
 ```
 
-The replacement must satisfy the original service contract. Each fork creates
-its own instances and owns its own cleanup; close it separately.
+The replacement must satisfy the original service contract. Each fork has
+independent acquisition and cleanup ownership; close it separately. Factories
+can still return shared objects captured outside the fork.
 
 ## Work with async services
 
@@ -192,6 +163,32 @@ The [tutorial](docs/guides/tutorial.md) also covers modules with private service
 typed tokens, class and function adapters, optional and lazy dependencies,
 collections, startup, metadata, observers, and plugin validation.
 
+## LLM harnesses and agent graphs
+
+Compose an **LLM harness** from model clients, tools, context sources, and
+ordinary functions that serve as **agent graph** nodes.
+
+- **Explicit feature boundaries:** give each node or tool a small contract
+  and private implementation. Keep feature contracts and focused tests together;
+  select tools and context for the LLM in the harness.
+- **Contract checks and fixture tests:** check declared wiring before a model call,
+  then fork the composition with typed model and tool fixtures for deterministic
+  behavioral tests. Keep live-model evals for quality and task success.
+- **Inspectable capability descriptions:** describe public nodes and tools next
+  to their factories. Inspect that metadata without creating services, and use
+  it in application-defined catalogs, diagnostics, or dispatch policies.
+
+DI Bag's dependency graph describes how services are supplied. The agent graph
+describes execution: which node runs next and what state it receives. Your
+harness or graph framework owns routing, retries, persistence, and execution;
+DI Bag supplies checked composition and resource ownership.
+
+The [agent harness and graph guide](docs/guides/agent-harnesses-and-graphs.md)
+combines private feature modules, an LLM-backed node, metadata inspection, and
+fork-based fixture tests in one runnable example. Inspection describes selected
+registrations, not complete dependency edges; observers track acquisition, not
+ordinary node calls. Use your graph framework for workflow checkpoints.
+
 ## How it compares
 
 DI Bag's appeal is the combination of object-parameter factories, checks across
@@ -250,6 +247,7 @@ for both setup options.
 | [Complete tutorial](docs/guides/tutorial.md) | Learn every public API through examples, from first composition to advanced ownership. |
 | [API reference](docs/guides/api-reference.md) | Exact generated signatures, overloads, type parameters, and API inventories. |
 | [Server guide](docs/guides/server-integration.md) | Node HTTP, Express, Fastify, Bun, and Deno: shared services, request scopes, startup, and shutdown. |
+| [Agent harnesses and graphs](docs/guides/agent-harnesses-and-graphs.md) | Compose model and tool dependencies, inspect metadata, and test nodes with typed fixtures. |
 | [Runnable examples](examples) | Modules, tokens, composition, collections, plugins, observers, scopes, and provider metadata. |
 | [Integration guide](docs/guides/enterprise-integration.md) | Tested recipes for request ownership, substitutions, and dynamic features. |
 | [Comparison with alternatives](docs/guides/comparison.md) | When DI Bag or another approach may be a better fit, with primary sources. |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "di-bag",
-  "version": "0.1.0",
-  "description": "Type-checked dependency composition with lazy factories, forks, and optional disposal.",
+  "version": "0.1.1",
+  "description": "Type-checked dependency composition, private modules, and resource ownership for TypeScript apps and LLM harnesses.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -49,7 +49,20 @@
   },
   "keywords": [
     "di",
-    "bag"
+    "bag",
+    "dependency-injection",
+    "typescript",
+    "modularity",
+    "context-engineering",
+    "agentic",
+    "agentic-development",
+    "llm",
+    "harness",
+    "agent-harness",
+    "graph",
+    "agent-graph",
+    "evals",
+    "metadata"
   ],
   "author": "Dany Fedorov",
   "license": "MIT",