Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@cmd/run.go`:
- Around line 403-408: When populating req.ResponseFormat and when printing the
verbose/dry-run paramsLine, avoid treating the literal "text" as an active
constraint; use the same predicate the provider uses (i.e., the
provider.ResponseFormat.IsSet() semantics) instead of
cfg.Params.ResponseFormat.IsSet() so that "text" is treated as unset/omitted.
Concretely, change the branches that currently check
cfg.Params.ResponseFormat.IsSet() (the block assigning req.ResponseFormat and
the verbose/dry-run paramsLine branches) to check the provider-style predicate
or replicate its logic (ignore Type == "text" as equivalent to unset) before
assigning req.ResponseFormat or appending response_format to the printed
paramsLine.

In `@internal/agent/agent.go`:
- Around line 191-200: The validator currently lets a
params.response_format.schema be provided without a response_format.type and
silently ignores it; update the validation in agent.go to explicitly reject
cases where cfg.Params.ResponseFormat.Schema is non-empty but
cfg.Params.ResponseFormat.Type is empty or missing: add a guard that checks
len(cfg.Params.ResponseFormat.Schema) > 0 && cfg.Params.ResponseFormat.Type ==
"" and return a ValidationError with a clear message (e.g.,
"params.response_format.type is required when params.response_format.schema is
provided"). Keep the existing type whitelist check (switch on
cfg.Params.ResponseFormat.Type) and the json_schema-specific schema-required
check, but ensure the new guard runs early enough to catch schema-only blocks
even when IsSet() is false.

In `@internal/provider/ollama.go`:
- Around line 544-557: The helper buildOllamaFormat currently downgrades
ResponseFormat{Type:"json_schema"} with an empty Schema to "json"; change
buildOllamaFormat to return an error when rf.Type == "json_schema" but rf.Schema
is empty (instead of returning "json") so callers know the input constraint
failed, and keep the existing behavior of returning the schema map when
non-empty; update Send and SendStream to call buildOllamaFormat, detect that
error, and wrap it in a ProviderError with category Input before
marshaling/returning (use the ProviderError type and Input category to follow
the provider error guidelines).

In `@internal/provider/openai.go`:
- Around line 353-374: The buildOpenAIResponseFormat function must validate that
a ResponseFormat with Type == "json_schema" contains a non-empty schema (aside
from an optional "name") and return a categorized ProviderError instead of
producing an invalid payload; change buildOpenAIResponseFormat to return
(*openaiResponseFormat, error), check when rf.Type == "json_schema" that
rf.Schema has at least one key other than "name" (or else return a ProviderError
indicating a malformed response format), and on success construct and return the
openaiResponseFormat (openaiJSONSchemaConfig{Name, Strict:true, Schema:...})
with nil error; update all callers of buildOpenAIResponseFormat to handle the
error and propagate or surface the ProviderError appropriately.

---

Nitpick comments:
In `@internal/provider/ollama_test.go`:
- Around line 1198-1301: Add a table-driven test that exercises both Send and
SendStream for the same ResponseFormat cases (omitted, json_object, json_schema)
so the stream path is validated; create a []struct{name string, format
ResponseFormat, want...} loop and for each case call o.Send and o.SendStream (or
a helper that invokes both) against an httptest.Server handler that inspects the
request body for the "format" field (as existing tests do), asserting the
expected presence/shape (string "json" for json_object, stripped schema object
for json_schema, and omitted when empty); reuse the existing test logic and
symbols (Send, SendStream, ResponseFormat) and follow the table-driven pattern
used in other *_test.go files.

In `@internal/provider/openai_test.go`:
- Around line 1520-1647: Add table-driven tests mirroring the three existing
TestOpenAI_Send_* cases but exercising SendStream instead of Send: create a
[]struct with name, request (using Request and ResponseFormat), expected
presence/type of response_format, and streaming=true; for each case start an
httptest.Server that inspects the incoming request body for "response_format"
like the existing tests, call NewOpenAI(...,
WithOpenAIBaseURL(server.URL)).SendStream(ctx, req), and assert the
response_format presence and fields (type, json_schema.strict/name/schema) match
expectations; ensure you cover the omit case, json_object case, and json_schema
case and follow the table-driven pattern per test file guidelines.

In `@internal/provider/provider.go`:
- Around line 71-74: The method ResponseFormat.IsSet() currently returns false
for Type == "text" which is confusing because that value can be explicitly
configured; update naming/comment to reflect that the method checks whether a
constraint is active (not merely configured). Rename the method IsSet to
IsConstrained (or change the doc comment) so the contract matches behavior, and
update all call sites referencing ResponseFormat.IsSet to use
ResponseFormat.IsConstrained (or keep IsSet and change its comment to
"IsConstrained / returns true when a constraint is active"); ensure the symbol
ResponseFormat and its method rename are updated consistently across the
codebase and unit tests.

Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@internal/provider/ollama.go`:
- Around line 552-578: Extract the repeated "copy schema map minus the 'name'
key" logic into a small helper (e.g., stripSchemaName) and use it from
buildOllamaFormat and buildOpenAIResponseFormat to avoid duplication and keep
behavior in sync; implement a function that accepts map[string]interface{} and
returns a new map[string]interface{} without the "name" key, then replace the
manual copy loops in buildOllamaFormat and buildOpenAIResponseFormat with calls
to that helper.