# TeaQL Python Tool API: HTTP The HTTP provider accepts a trusted asynchronous transport and is denied by default. The application composition root owns provider registration and the explicit allow policy. ```python from teaql.runtime import ContextTools, HTTP_TOOL, HttpToolProvider, ToolPolicy tools = (ContextTools.builder(ctx) .policy(ToolPolicy.allowing(HTTP_TOOL)) .provider(HttpToolProvider(application_http_transport)) .build()) body: str = await (tools.get(HTTP_TOOL) .get("https://example.com/status") .purpose("read the external service status") .execute()) ``` Exact type-state API: - `HttpTool.get(url)` and `post(url, body)` return `HttpIntentPhase`; - `purpose(intent)` or `audit_as(intent)` returns `ExecutableHttpTool`; - `await execute()` returns native `str` and rejects blank intent or non-2xx status; - provider absence, unknown token, and denied policy use explicit Tool exception types. POST bodies are compact JSON bytes passed to the injected transport. Preserve the native response shape and reject unknown operations instead of inventing them. --- ## TeaQL seven-language assist contract Apply the verified Rust semantic ceiling while using only the exact PYTHON generated and runtime APIs. Discover APIs through the generated application AGENTS.md and progressive model-aware Assist. Do not inspect generated domain-library source. - Do not create plurals by appending `s` or `es`; use the centralized generated plural. - Human and non-human entities use different generated predicate vocabularies. Preserve forms such as “who are active” and “whose email is”; never infer them from English. - Configure filters, projection, paging, and other query options before `purpose(...)`. Comment may appear anywhere in the chain. Purpose enters the executable stage; execution requires both values, but comment does not have to immediately precede purpose. - Every execute/list/stream and every save accepts exactly one context argument: `UserContext`. Name that argument `context`, never `runtime`; data services and global policy are injected when the context is built. Reserve `runtime` for process-level runtime ownership, provider/pool setup, and module assembly. - Tenant, merchant, identity, permissions, request policy, purpose policy, hard limit, and continuous-page cursor policy come only from trusted context, never dynamic JSON or TFP. - If the required operation is absent after current entity/action and required field Assist, stop that path and report MISSING_ASSIST. Do not guess an API or search the generated library as a fallback. - Create each application-owned source file once. After its first compile attempt, repair only the smallest block identified by the exact compiler or test diagnostic. Preserve unrelated code; do not rewrite the complete file as an error-recovery loop. - Before a repair that would replace more than 25% of an existing application file, stop and report LARGE_REWRITE_REQUEST with the file, exact diagnostic, reason, and estimated scope. Initial creation and model-driven regeneration are not repairs. Capability: `tool-api`. - Treat generated entity, request, expression, and tool documentation as the API source of truth. Compile the produced code and retain the native response shape. - Reject unknown modules, fields, operations, and policy overrides explicitly.