diff --git a/crates/goose-providers/src/declarative.rs b/crates/goose-providers/src/declarative.rs index 5ee57f27c..d09b4f5cd 100644 --- a/crates/goose-providers/src/declarative.rs +++ b/crates/goose-providers/src/declarative.rs @@ -59,6 +59,7 @@ pub(crate) mod declarative_providers { venice, vercel_ai_gateway, zai, + zai_coding_plan, zhipu, ); } diff --git a/crates/goose-providers/src/declarative/definitions/zai_coding_plan.json b/crates/goose-providers/src/declarative/definitions/zai_coding_plan.json new file mode 100644 index 000000000..9f548703b --- /dev/null +++ b/crates/goose-providers/src/declarative/definitions/zai_coding_plan.json @@ -0,0 +1,31 @@ +{ + "name": "zai_coding_plan", + "engine": "openai", + "display_name": "Z.AI Coding Plan", + "description": "GLM models through the Z.AI Coding Plan with streaming tool calls", + "api_key_env": "ZAI_CODING_PLAN_API_KEY", + "base_url": "https://api.z.ai/api/coding/paas/v4", + "model_doc_link": "https://docs.z.ai/devpack/overview", + "preserves_thinking": true, + "dynamic_models": true, + "models": [ + { + "name": "glm-5.3", + "context_limit": 1000000, + "reasoning": true + }, + { + "name": "glm-5.3-flash", + "context_limit": 1000000, + "reasoning": true + } + ], + "supports_streaming": true, + "setup": { + "category": "model", + "setup_method": "single_api_key", + "group": "additional", + "docs_url": "https://docs.z.ai/devpack/overview", + "aliases": ["z.ai coding plan", "glm coding plan"] + } +} diff --git a/crates/goose-providers/src/openai.rs b/crates/goose-providers/src/openai.rs index a95fcbd7e..490b017d4 100644 --- a/crates/goose-providers/src/openai.rs +++ b/crates/goose-providers/src/openai.rs @@ -417,6 +417,10 @@ impl OpenAiProvider { const PROVIDERS_NEEDING_STANDARD_CHAT_PARAMS: &[&str] = &["nearai", "pleumrouter"]; + /// Providers whose endpoints require the non-standard `tool_stream` + /// field to stream tool-call arguments incrementally. + const PROVIDERS_NEEDING_TOOL_STREAM: &[&str] = &["zai_coding_plan"]; + /// Providers whose reasoning models accept an OpenAI-style /// `reasoning_effort` field on chat-completions requests but aren't /// matched by [`is_openai_responses_model`] (which only recognises @@ -452,6 +456,12 @@ impl OpenAiProvider { model_config: &ModelConfig, ) -> serde_json::Value { if let Some(obj) = payload.as_object_mut() { + if Self::PROVIDERS_NEEDING_TOOL_STREAM.contains(&self.name.as_str()) + && obj.get("stream") == Some(&json!(true)) + { + obj.entry("tool_stream").or_insert(json!(true)); + } + if Self::PROVIDERS_NEEDING_MAX_TOKENS_REMAP.contains(&self.name.as_str()) { if let Some(value) = obj.remove("max_completion_tokens") { obj.entry("max_tokens").or_insert(value); @@ -1001,6 +1011,28 @@ mod tests { } } + #[test] + fn coding_plan_tool_stream_is_scoped_and_preserves_explicit_overrides() { + let model = ModelConfig::new("glm-future"); + for (provider, payload, expected) in [ + ( + "zai_coding_plan", + json!({"stream": true}), + Some(json!(true)), + ), + ("zai_coding_plan", json!({"stream": false}), None), + ("openai", json!({"stream": true}), None), + ( + "zai_coding_plan", + json!({"stream": true, "tool_stream": false}), + Some(json!(false)), + ), + ] { + let request = make_provider(provider).sanitize_request_for_compat(payload, &model); + assert_eq!(request.get("tool_stream"), expected.as_ref()); + } + } + #[test] fn sanitize_remaps_max_completion_tokens_for_compat_provider() { let provider = make_provider("mistral"); diff --git a/crates/goose-providers/tests/zai_coding_plan.rs b/crates/goose-providers/tests/zai_coding_plan.rs new file mode 100644 index 000000000..6fc4b6b38 --- /dev/null +++ b/crates/goose-providers/tests/zai_coding_plan.rs @@ -0,0 +1,222 @@ +use futures::StreamExt; +use goose_providers::{ + base::Provider, + conversation::message::{Message, MessageContentBlock}, + declarative::{deserialize_provider_config, KeyResolver}, + model::ModelConfig, + openai::from_declarative_config, + zai_coding_plan, +}; +use rmcp::model::{CallToolResult, ContentBlock, Tool}; +use serde_json::{json, Value}; +use std::{convert::Infallible, sync::Arc, time::Duration}; +use wiremock::{ + matchers::{body_partial_json, header, method, path}, + Mock, MockServer, ResponseTemplate, +}; + +struct TestKey; + +impl KeyResolver for TestKey { + type Error = Infallible; + + fn resolve_key(&self, key: &str) -> Result { + assert_eq!(key, "ZAI_CODING_PLAN_API_KEY"); + Ok("test-key".into()) + } +} + +fn provider(server: &MockServer) -> impl Provider { + let mut config = deserialize_provider_config(zai_coding_plan::JSON).unwrap(); + assert_eq!(config.base_url, "https://api.z.ai/api/coding/paas/v4"); + config.base_url = format!("{}/api/coding/paas/v4", server.uri()); + from_declarative_config(config, None, TestKey) + .unwrap() + .build() +} + +fn tool() -> Tool { + Tool::new( + "write_file", + "Write a file", + Arc::new( + json!({"type":"object","properties":{"text":{"type":"string"}},"required":["text"]}) + .as_object() + .unwrap() + .clone(), + ), + ) +} + +fn sse(deltas: Vec, finish: &str) -> String { + let mut body = String::new(); + for delta in deltas { + body.push_str(&format!( + "data: {}\n\n", + json!({"id":"response-1","model":"glm-5.3","choices":[{"index":0,"delta":delta,"finish_reason":null}]}) + )); + } + body.push_str(&format!( + "data: {}\n\ndata: [DONE]\n\n", + json!({"id":"response-1","model":"glm-5.3","choices":[{"index":0,"delta":{},"finish_reason":finish}], + "usage":{"prompt_tokens":20,"completion_tokens":10,"total_tokens":30}}) + )); + body +} + +#[tokio::test] +async fn streams_fragmented_tools_and_replays_reasoning_with_tool_results() { + let server = MockServer::start().await; + let provider = provider(&server); + Mock::given(method("GET")) + .and(path("/api/coding/paas/v4/models")) + .and(header("authorization", "Bearer test-key")) + .respond_with(ResponseTemplate::new(200).set_body_json(json!({ + "data": [{"id":"glm-5.3"}, {"id":"glm-5.3-flash"}, {"id":"glm-future"}] + }))) + .expect(1) + .mount(&server) + .await; + assert_eq!( + provider.fetch_supported_models().await.unwrap(), + ["glm-5.3", "glm-5.3-flash", "glm-future"] + ); + server.verify().await; + server.reset().await; + + for model in ["glm-5.3", "glm-5.3-flash", "glm-future"] { + let response = sse( + vec![ + json!({"role":"assistant","reasoning_content":"Inspect first. "}), + json!({"reasoning_content":"Then write."}), + json!({"tool_calls":[{"index":0,"id":"call-1","type":"function","function":{"name":"write_file","arguments":""}}]}), + json!({"tool_calls":[{"index":0,"function":{"arguments":"{\"text\":\"Hello"}}]}), + json!({"tool_calls":[{"index":0,"function":{"arguments":" \\u4e16\\u754c\\n\"}"}}]}), + ], + "tool_calls", + ); + Mock::given(method("POST")) + .and(path("/api/coding/paas/v4/chat/completions")) + .and(header("authorization", "Bearer test-key")) + .and(body_partial_json( + json!({"model":model,"stream":true,"tool_stream":true}), + )) + .respond_with(ResponseTemplate::new(200).set_body_raw(response, "text/event-stream")) + .expect(1) + .mount(&server) + .await; + + let mut messages = vec![Message::user().with_text("Write the greeting")]; + let (reply, usage) = provider + .complete( + &ModelConfig::new(model), + "You are a coding assistant", + &messages, + &[tool()], + ) + .await + .unwrap(); + assert_eq!(usage.usage.total_tokens, Some(30)); + let calls: Vec<_> = reply + .content + .iter() + .filter_map(|block| match block { + MessageContentBlock::ToolRequest(request) => Some(request), + _ => None, + }) + .collect(); + assert_eq!(calls.len(), 1); + assert_eq!(calls[0].id, "call-1"); + let call = calls[0].tool_call.as_ref().unwrap(); + assert_eq!(call.name, "write_file"); + assert_eq!( + call.arguments, + Some(json!({"text":"Hello δΈ–η•Œ\n"}).as_object().unwrap().clone()) + ); + messages.push(reply); + messages.push(Message::user().with_tool_response( + "call-1", + Ok(CallToolResult::success(vec![ContentBlock::text("Written")])), + )); + server.verify().await; + server.reset().await; + + Mock::given(method("POST")) + .respond_with(ResponseTemplate::new(200).set_body_raw( + sse(vec![json!({"content":"Done"})], "stop"), + "text/event-stream", + )) + .expect(1) + .mount(&server) + .await; + let (reply, _) = provider + .complete( + &ModelConfig::new(model), + "You are a coding assistant", + &messages, + &[tool()], + ) + .await + .unwrap(); + assert_eq!(reply.as_concat_text(), "Done"); + let requests = server.received_requests().await.unwrap(); + let body: Value = requests[0].body_json().unwrap(); + let history = body["messages"].as_array().unwrap(); + let assistant = history.iter().find(|m| m["role"] == "assistant").unwrap(); + assert_eq!(assistant["reasoning_content"], "Inspect first. Then write."); + assert_eq!(assistant["tool_calls"][0]["id"], "call-1"); + let result = history.iter().find(|m| m["role"] == "tool").unwrap(); + assert_eq!(result["tool_call_id"], "call-1"); + assert_eq!(body["tool_stream"], true); + server.verify().await; + server.reset().await; + } +} + +#[tokio::test] +async fn cancelled_request_does_not_contaminate_next_turn() { + let server = MockServer::start().await; + let provider = provider(&server); + Mock::given(method("POST")) + .respond_with(ResponseTemplate::new(200).set_delay(Duration::from_secs(10))) + .mount(&server) + .await; + let model = ModelConfig::new("glm-5.3"); + assert!(tokio::time::timeout( + Duration::from_millis(100), + provider.stream( + &model, + "system", + &[Message::user().with_text("Old task")], + &[tool()] + ), + ) + .await + .is_err()); + server.reset().await; + Mock::given(method("POST")) + .and(body_partial_json(json!({"stream":true,"tool_stream":true}))) + .respond_with(ResponseTemplate::new(200).set_body_raw( + sse(vec![json!({"content":"New task"})], "stop"), + "text/event-stream", + )) + .expect(1) + .mount(&server) + .await; + let mut stream = provider + .stream( + &model, + "system", + &[Message::user().with_text("New task")], + &[], + ) + .await + .unwrap(); + let mut text = String::new(); + while let Some(chunk) = stream.next().await { + if let (Some(message), _) = chunk.unwrap() { + text.push_str(&message.as_concat_text()); + } + } + assert_eq!(text, "New task"); +} diff --git a/documentation/docs/getting-started/providers.md b/documentation/docs/getting-started/providers.md index d6d18618d..5312188d9 100644 --- a/documentation/docs/getting-started/providers.md +++ b/documentation/docs/getting-started/providers.md @@ -91,6 +91,29 @@ goose supports [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) a See the [ACP Providers guide](/docs/guides/acp-providers) for detailed setup instructions. ::: +### Z.AI Coding Plan + +In goose Desktop, open **Settings β†’ Models**, choose **Z.AI Coding Plan**, and +enter your Coding Plan API key. The model selector discovers available models +from your Coding Plan endpoint; use **Refresh** to update the list. +Z.AI may list models that your subscription cannot use; access is checked when +you send a request. + +In the CLI, select **Z.AI Coding Plan** in `goose configure` and supply your Coding Plan API key, +or set `GOOSE_PROVIDER=zai_coding_plan`, `GOOSE_MODEL=glm-5.3`, and +`ZAI_CODING_PLAN_API_KEY`. GLM-5.3 and GLM-5.3-Flash are the fallback choices +when the endpoint does not support model discovery. + +This provider uses the dedicated OpenAI-compatible endpoint +`https://api.z.ai/api/coding/paas/v4`. It enables both `stream` and `tool_stream` +for streaming requests, including newly discovered models, so tool arguments arrive incrementally, and preserves +`reasoning_content` across tool-result turns. The existing **Z.AI** provider +continues to use the Anthropic-compatible endpoint. + +See Z.AI's [Coding Plan model availability](https://docs.z.ai/devpack/overview), +[tool streaming](https://docs.z.ai/guides/capabilities/stream-tool), and +[thinking preservation](https://docs.z.ai/guides/capabilities/thinking-mode) documentation. + ## Configure Provider and Model To configure your chosen provider, see available options, or select a model, visit the `Models` tab in goose Desktop or run `goose configure` in the CLI. diff --git a/goose-self-test.yaml b/goose-self-test.yaml index 1386c9272..b87d74444 100644 --- a/goose-self-test.yaml +++ b/goose-self-test.yaml @@ -15,6 +15,7 @@ activities: - Test load tool for knowledge injection and discovery - Test delegate tool for task delegation (sync and async) - Test multi-turn thinking preservation for providers that reject replayed reasoning_content + - Test Z.AI Coding Plan streamed tool calls and interruption recovery - Validate ACP thinking-effort discovery, forwarding, and provider switching - Validate GDK observability hook lifecycle events and payload opt-in - Test error boundaries including nested delegation prevention @@ -25,7 +26,7 @@ parameters: input_type: string requirement: optional default: "all" - description: "Which test phases to run: all, basic, extensions, delegation, reasoning, acp-effort, advanced" + description: "Which test phases to run: all, basic, extensions, delegation, reasoning, zai-coding-plan, acp-effort, advanced" - key: test_depth input_type: string @@ -408,6 +409,30 @@ prompt: | Log results to: {{ workspace_dir }}/phase3c_reasoning.md {% endif %} + {% if test_phases == "all" or "zai-coding-plan" in test_phases %} + ## Z.AI Coding Plan + + **Prerequisites**: The active provider must be `zai_coding_plan`, with a Coding Plan API key + configured and the developer extension enabled. Otherwise record this phase as SKIPPED. + + In Desktop, confirm the provider appears in Settings β†’ Models, accepts the API key, + and refreshes available models from the Coding Plan endpoint. Record this UI check + as SKIPPED in headless mode. Newly discovered models must also use `tool_stream`. + + 1. Use the file-writing tool to create a substantial Python module in the test workspace + in a single call, including Unicode text and escaped newlines. Read it back and run it. + 2. Modify that module in a second tool call, then run it again. Verify the tool-result + continuation succeeds without malformed JSON, missing tool IDs, or reasoning errors. + 3. Ask the human tester to interrupt a long response with Ctrl+C and give a replacement + instruction. Verify the next turn follows the replacement and tool use still works. + In headless mode, mark this interactive step SKIPPED rather than claiming success. + 4. When transport diagnostics are available, verify `stream: true` and `tool_stream: true` + on requests, multiple argument deltas for the large tool call, and unmodified + `reasoning_content` on subsequent tool-result turns. Never log API keys. + + Log results to: {{ workspace_dir }}/zai_coding_plan.md + {% endif %} + {% if test_phases == "all" or "acp-effort" in test_phases %} ## 🧠 PHASE 3D: ACP Thinking-Effort Testing diff --git a/ui/desktop/src/acp/__tests__/providers.test.ts b/ui/desktop/src/acp/__tests__/providers.test.ts index b0a1bb421..b75a305ad 100644 --- a/ui/desktop/src/acp/__tests__/providers.test.ts +++ b/ui/desktop/src/acp/__tests__/providers.test.ts @@ -30,6 +30,49 @@ describe('ACP providers', () => { vi.clearAllMocks(); }); + it('exposes Coding Plan in Desktop setup and refreshes newly discovered models', async () => { + const entry = providerEntry({ + providerId: 'zai_coding_plan', + providerName: 'Z.AI Coding Plan', + providerType: 'Declarative', + acp: false, + configKeys: [{ name: 'ZAI_CODING_PLAN_API_KEY', required: true, secret: true }], + }); + const discovered = { + ...entry, + models: [{ id: 'glm-future', name: 'glm-future', recommended: true }], + }; + const client = { + goose: { + providersList_unstable: vi + .fn() + .mockResolvedValueOnce({ entries: [entry] }) + .mockResolvedValueOnce({ entries: [entry] }) + .mockResolvedValueOnce({ entries: [discovered] }), + providersReadinessCheck_unstable: vi.fn().mockResolvedValue({ ready: true }), + providersInventoryRefresh_unstable: vi + .fn() + .mockResolvedValue({ started: ['zai_coding_plan'], skipped: [] }), + }, + }; + vi.mocked(getAcpClient).mockResolvedValue( + client as unknown as Awaited> + ); + + const setup = await acpListSetupProviderDetails(); + expect(setup[0].metadata.display_name).toBe('Z.AI Coding Plan'); + expect(setup[0].supports_refresh).toBe(true); + expect(setup[0].metadata.config_keys[0].name).toBe('ZAI_CODING_PLAN_API_KEY'); + + const refreshed = await acpRefreshProviderDetails('zai_coding_plan'); + expect(client.goose.providersInventoryRefresh_unstable).toHaveBeenCalledWith({ + providerIds: ['zai_coding_plan'], + }); + expect(refreshed.provider.metadata.known_models.map((model) => model.name)).toEqual([ + 'glm-future', + ]); + }); + it('sets thinking effort after provider and model, then returns the final config response', async () => { const client = { connection: { diff --git a/ui/desktop/src/components/settings/providers/modal/ProviderConfigurationModal.test.tsx b/ui/desktop/src/components/settings/providers/modal/ProviderConfigurationModal.test.tsx index 4363f6135..d8498636c 100644 --- a/ui/desktop/src/components/settings/providers/modal/ProviderConfigurationModal.test.tsx +++ b/ui/desktop/src/components/settings/providers/modal/ProviderConfigurationModal.test.tsx @@ -1,7 +1,11 @@ import { render, screen, waitFor } from '@testing-library/react'; import userEvent from '@testing-library/user-event'; import { describe, expect, it, vi } from 'vitest'; -import { acpEnableProvider, acpRefreshProviderDetails } from '../../../../acp/providers'; +import { + acpEnableProvider, + acpRefreshProviderDetails, + acpSaveProviderConfig, +} from '../../../../acp/providers'; import { IntlTestWrapper } from '../../../../i18n/test-utils'; import type { ProviderDetails } from '../../../../types/providers'; import ProviderConfigurationModal from './ProviderConfigurationModal'; @@ -22,6 +26,7 @@ vi.mock('../../../../acp/providers', () => ({ acpEnableProvider: vi.fn(), acpRefreshProviderDetails: vi.fn(), acpSaveProviderConfig: vi.fn(), + acpReadProviderConfig: vi.fn().mockResolvedValue([]), })); const oauthProvider: ProviderDetails = { @@ -51,6 +56,49 @@ const oauthProvider: ProviderDetails = { }; describe('ProviderConfigurationModal', () => { + it('configures Z.AI Coding Plan through the standard Desktop API key form', async () => { + const user = userEvent.setup(); + const onConfigured = vi.fn(); + const provider: ProviderDetails = { + ...oauthProvider, + name: 'zai_coding_plan', + provider_type: 'Declarative', + is_configured: false, + supports_refresh: true, + metadata: { + ...oauthProvider.metadata, + name: 'zai_coding_plan', + display_name: 'Z.AI Coding Plan', + default_model: 'glm-5.3', + config_keys: [ + { name: 'ZAI_CODING_PLAN_API_KEY', required: true, secret: true, oauth_flow: false }, + ], + }, + }; + vi.mocked(acpSaveProviderConfig).mockResolvedValue(undefined); + render( + , + { + wrapper: IntlTestWrapper, + } + ); + + expect(screen.getByRole('heading', { name: /Configure Z.AI Coding Plan/ })).toBeInTheDocument(); + await user.type(await screen.findByPlaceholderText('Your API key'), 'test-coding-plan-key'); + await user.click(screen.getByRole('button', { name: 'Submit' })); + + await waitFor(() => + expect(acpSaveProviderConfig).toHaveBeenCalledWith('zai_coding_plan', [ + { key: 'ZAI_CODING_PLAN_API_KEY', value: 'test-coding-plan-key' }, + ]) + ); + expect(onConfigured).toHaveBeenCalledWith(provider); + }); + it('offers to remove an existing OAuth configuration without an ACP readiness check', () => { render(, { wrapper: IntlTestWrapper,