cccc-sdk 0.1.4 → 0.4.3

package/dist/client.js

@@ -1,8 +1,7 @@
 /**
  * CCCC SDK client
  */
-import { DaemonAPIError, IncompatibleDaemonError, ErrorCodes, } from './errors.js';
-import { isStreamEvent } from './types.js';
+import { DaemonAPIError, IncompatibleDaemonError, } from './errors.js';
 import { discoverEndpoint, callDaemon, openEventsStream, readLines, } from './transport.js';
 /**
  * Client for communicating with the CCCC daemon over IPC (Unix socket or TCP).
@@ -51,23 +50,22 @@ export class CCCCClient {
             args: args ?? {},
         };
         const response = await callDaemon(this._endpoint, request, this._timeoutMs);
-        if (!response.ok) {
-            throw new DaemonAPIError(response.error?.code ?? 'error', response.error?.message ?? 'daemon error', response.error?.details ?? {}, response);
+        if (!response.ok && response.error) {
+            throw new DaemonAPIError(response.error.code ?? 'error', response.error.message ?? 'daemon error', response.error.details ?? {}, response);
         }
         return response;
     }
     /**
      * Send an IPC request and return only the result payload.
-     * @typeParam T - Expected result type (defaults to `Record<string, unknown>`).
      * @param op - The IPC operation name.
      * @param args - Operation arguments.
-     * @returns The `result` field from the daemon response, cast to `T`.
+     * @returns The `result` field from the daemon response (empty object if absent).
      * @throws {DaemonAPIError} If the daemon returns an error.
      * @throws {DaemonUnavailableError} If the connection fails.
      */
     async call(op, args) {
         const response = await this.callRaw(op, args);
-        return (response.result ?? {});
+        return response.result ?? {};
     }
     /**
      * Assert that the connected daemon meets the caller's compatibility requirements.
@@ -79,8 +77,12 @@ export class CCCCClient {
      */
     async assertCompatible(options = {}) {
         const pingResult = await this.ping();
-        const ipcV = pingResult.ipc_v ?? 0;
-        const capabilities = pingResult.capabilities ?? {};
+        const rawIpcV = pingResult['ipc_v'];
+        const ipcV = typeof rawIpcV === 'number' ? rawIpcV : 0;
+        const rawCaps = pingResult['capabilities'];
+        const capabilities = (rawCaps !== null && typeof rawCaps === 'object' && !Array.isArray(rawCaps))
+            ? rawCaps
+            : {};
         // Check IPC version
         const requiredV = options.requireIpcV ?? 1;
         if (ipcV < requiredV) {
@@ -101,7 +103,7 @@ export class CCCCClient {
                 await this.callRaw(op, {});
             }
             catch (e) {
-                if (e instanceof DaemonAPIError && e.code === ErrorCodes.UNKNOWN_OP) {
+                if (e instanceof DaemonAPIError && e.code === 'unknown_op') {
                     throw new IncompatibleDaemonError(`Operation not supported: ${op}`);
                 }
                 // Other errors (e.g. missing_group_id) imply the operation exists.
@@ -205,7 +207,7 @@ export class CCCCClient {
     async groupAutomationManage(options) {
         const actions = options.actions;
         if (actions.length === 0) {
-            throw new DaemonAPIError(ErrorCodes.INVALID_ARGS, 'groupAutomationManage requires a non-empty actions array', {});
+            throw new DaemonAPIError('invalid_args', 'groupAutomationManage requires a non-empty actions array', {});
         }
         const args = {
             group_id: options.groupId,
@@ -274,6 +276,8 @@ export class CCCCClient {
             command: options.command,
             env: options.env,
             env_private: options.envPrivate,
+            capability_autoload: options.capabilityAutoload,
+            profile_id: options.profileId,
             default_scope_key: options.defaultScopeKey,
             submit: options.submit,
         };
@@ -291,12 +295,17 @@ export class CCCCClient {
      * Update actor
      */
     async actorUpdate(options) {
-        return this.call('actor_update', {
+        const args = {
             group_id: options.groupId,
             actor_id: options.actorId,
-            patch: options.patch,
+            patch: options.patch ?? {},
             by: options.by ?? 'user',
-        });
+        };
+        if (options.profileId != null)
+            args['profile_id'] = options.profileId;
+        if (options.profileAction != null)
+            args['profile_action'] = options.profileAction;
+        return this.call('actor_update', args);
     }
     /**
      * Remove actor
@@ -305,25 +314,10 @@ export class CCCCClient {
         return this.call('actor_remove', { group_id: groupId, actor_id: actorId, by });
     }
     /**
-     * Start actor.
-     * @param groupId - Group ID.
-     * @param actorId - Actor ID.
-     * @param options - Optional settings. Pass `{ idempotent: true }` to suppress errors when the actor is already running.
-     * @returns The daemon result.
-     * @throws {DaemonAPIError} On error (unless idempotent and actor already running).
+     * Start actor
      */
-    async actorStart(groupId, actorId, options) {
-        const by = typeof options === 'string' ? options : (options?.by ?? 'user');
-        const idempotent = typeof options === 'object' && options?.idempotent === true;
-        try {
-            return await this.call('actor_start', { group_id: groupId, actor_id: actorId, by });
-        }
-        catch (e) {
-            if (idempotent && e instanceof DaemonAPIError && e.code === ErrorCodes.CONFLICT) {
-                return {};
-            }
-            throw e;
-        }
+    async actorStart(groupId, actorId, by = 'user') {
+        return this.call('actor_start', { group_id: groupId, actor_id: actorId, by });
     }
     /**
      * Stop actor
@@ -359,13 +353,299 @@ export class CCCCClient {
             args['unset'] = options.unset;
         return this.call('actor_env_private_update', args);
     }
+    /**
+     * List global actor profiles.
+     */
+    async actorProfileList(by = 'user') {
+        return this.call('actor_profile_list', { by });
+    }
+    /**
+     * Get one actor profile and current usage.
+     */
+    async actorProfileGet(profileId, by = 'user') {
+        return this.call('actor_profile_get', { profile_id: profileId, by });
+    }
+    /**
+     * Create/update one actor profile.
+     */
+    async actorProfileUpsert(options) {
+        const profile = { ...options.profile };
+        if ('capabilityDefaults' in profile) {
+            const rawDefaults = profile['capabilityDefaults'];
+            delete profile['capabilityDefaults'];
+            if (rawDefaults != null && typeof rawDefaults === 'object' && !Array.isArray(rawDefaults)) {
+                const defaults = rawDefaults;
+                profile['capability_defaults'] = {
+                    ...(defaults['autoloadCapabilities'] !== undefined
+                        ? { autoload_capabilities: defaults['autoloadCapabilities'] }
+                        : {}),
+                    ...(defaults['defaultScope'] !== undefined
+                        ? { default_scope: defaults['defaultScope'] }
+                        : {}),
+                    ...(defaults['sessionTtlSeconds'] !== undefined
+                        ? { session_ttl_seconds: defaults['sessionTtlSeconds'] }
+                        : {}),
+                };
+            }
+            else {
+                profile['capability_defaults'] = rawDefaults;
+            }
+        }
+        const args = {
+            profile,
+            by: options.by ?? 'user',
+        };
+        if (options.expectedRevision !== undefined)
+            args['expected_revision'] = options.expectedRevision;
+        return this.call('actor_profile_upsert', args);
+    }
+    /**
+     * Delete one actor profile (rejected when still in use).
+     */
+    async actorProfileDelete(profileId, by = 'user', forceDetach = false) {
+        return this.call('actor_profile_delete', { profile_id: profileId, by, force_detach: forceDetach });
+    }
+    /**
+     * List profile-level secret keys and masked previews.
+     */
+    async actorProfileSecretKeys(profileId, by = 'user') {
+        return this.call('actor_profile_secret_keys', { profile_id: profileId, by });
+    }
+    /**
+     * Update profile-level private env.
+     */
+    async actorProfileSecretUpdate(options) {
+        const args = {
+            profile_id: options.profileId,
+            by: options.by ?? 'user',
+            clear: options.clear ?? false,
+        };
+        if (options.set)
+            args['set'] = options.set;
+        if (options.unset)
+            args['unset'] = options.unset;
+        return this.call('actor_profile_secret_update', args);
+    }
+    /**
+     * Copy one actor's runtime env (public + private) into a profile's private env.
+     */
+    async actorProfileSecretCopyFromActor(options) {
+        return this.call('actor_profile_secret_copy_from_actor', {
+            profile_id: options.profileId,
+            group_id: options.groupId,
+            actor_id: options.actorId,
+            by: options.by ?? 'user',
+        });
+    }
+    /**
+     * Copy one profile's secrets into another profile.
+     */
+    async actorProfileSecretCopyFromProfile(options) {
+        return this.call('actor_profile_secret_copy_from_profile', {
+            profile_id: options.profileId,
+            source_profile_id: options.sourceProfileId,
+            by: options.by ?? 'user',
+        });
+    }
+    // ============================================================
+    // Convenience methods: capabilities
+    // ============================================================
+    /**
+     * Read the global capability overview snapshot.
+     */
+    async capabilityOverview(options = {}) {
+        const args = {};
+        if (options.query)
+            args['query'] = options.query;
+        if (options.limit !== undefined)
+            args['limit'] = options.limit;
+        if (options.includeIndexed !== undefined)
+            args['include_indexed'] = options.includeIndexed;
+        return this.call('capability_overview', args);
+    }
+    /**
+     * Search the capability registry for one group/caller scope.
+     */
+    async capabilitySearch(options) {
+        const args = {
+            group_id: options.groupId,
+            by: options.by ?? 'user',
+        };
+        if (options.actorId)
+            args['actor_id'] = options.actorId;
+        if (options.query)
+            args['query'] = options.query;
+        if (options.kind !== undefined)
+            args['kind'] = options.kind;
+        if (options.sourceId)
+            args['source_id'] = options.sourceId;
+        if (options.trustTier)
+            args['trust_tier'] = options.trustTier;
+        if (options.qualificationStatus !== undefined)
+            args['qualification_status'] = options.qualificationStatus;
+        if (options.includeExternal !== undefined)
+            args['include_external'] = options.includeExternal;
+        if (options.limit !== undefined)
+            args['limit'] = options.limit;
+        return this.call('capability_search', args);
+    }
+    /**
+     * Enable or disable a capability.
+     */
+    async capabilityEnable(options) {
+        const args = {
+            group_id: options.groupId,
+            capability_id: options.capabilityId,
+            scope: options.scope ?? 'session',
+            enabled: options.enabled ?? true,
+            cleanup: options.cleanup ?? false,
+            by: options.by ?? 'user',
+        };
+        if (options.reason)
+            args['reason'] = options.reason;
+        if (options.ttlSeconds !== undefined)
+            args['ttl_seconds'] = options.ttlSeconds;
+        if (options.actorId)
+            args['actor_id'] = options.actorId;
+        return this.call('capability_enable', args);
+    }
+    /**
+     * Block or unblock a capability.
+     */
+    async capabilityBlock(options) {
+        const args = {
+            group_id: options.groupId,
+            capability_id: options.capabilityId,
+            scope: options.scope ?? 'group',
+            blocked: options.blocked ?? true,
+            by: options.by ?? 'user',
+        };
+        if (options.ttlSeconds !== undefined)
+            args['ttl_seconds'] = options.ttlSeconds;
+        if (options.reason)
+            args['reason'] = options.reason;
+        if (options.actorId)
+            args['actor_id'] = options.actorId;
+        return this.call('capability_block', args);
+    }
+    /**
+     * Read effective capability exposure for one caller scope.
+     */
+    async capabilityState(options) {
+        const args = {
+            group_id: options.groupId,
+            by: options.by ?? 'user',
+        };
+        if (options.actorId)
+            args['actor_id'] = options.actorId;
+        return this.call('capability_state', args);
+    }
+    /**
+     * Read capability allowlist default, overlay, and effective snapshots.
+     */
+    async capabilityAllowlistGet(options = {}) {
+        return this.call('capability_allowlist_get', {
+            by: options.by ?? 'user',
+        });
+    }
+    /**
+     * Dry-run capability allowlist overlay validation without persistence.
+     */
+    async capabilityAllowlistValidate(options = {}) {
+        const args = {
+            mode: options.mode ?? 'patch',
+        };
+        if (options.patch !== undefined)
+            args['patch'] = options.patch;
+        if (options.overlay !== undefined)
+            args['overlay'] = options.overlay;
+        return this.call('capability_allowlist_validate', args);
+    }
+    /**
+     * Persist capability allowlist overlay with optional optimistic concurrency.
+     */
+    async capabilityAllowlistUpdate(options = {}) {
+        const args = {
+            by: options.by ?? 'user',
+            mode: options.mode ?? 'patch',
+        };
+        if (options.expectedRevision)
+            args['expected_revision'] = options.expectedRevision;
+        if (options.patch !== undefined)
+            args['patch'] = options.patch;
+        if (options.overlay !== undefined)
+            args['overlay'] = options.overlay;
+        return this.call('capability_allowlist_update', args);
+    }
+    /**
+     * Reset capability allowlist overlay to empty/default state.
+     */
+    async capabilityAllowlistReset(options = {}) {
+        return this.call('capability_allowlist_reset', {
+            by: options.by ?? 'user',
+        });
+    }
+    /**
+     * Import one structured capability record, with optional readiness probe.
+     */
+    async capabilityImport(options) {
+        const args = {
+            group_id: options.groupId,
+            record: options.record,
+            by: options.by ?? 'user',
+            dry_run: options.dryRun ?? false,
+        };
+        if (options.actorId)
+            args['actor_id'] = options.actorId;
+        if (options.probe !== undefined)
+            args['probe'] = options.probe;
+        if (options.enableAfterImport !== undefined)
+            args['enable_after_import'] = options.enableAfterImport;
+        if (options.scope)
+            args['scope'] = options.scope;
+        if (options.ttlSeconds !== undefined)
+            args['ttl_seconds'] = options.ttlSeconds;
+        if (options.reason)
+            args['reason'] = options.reason;
+        return this.call('capability_import', args);
+    }
+    /**
+     * Uninstall a capability from the target group scope.
+     */
+    async capabilityUninstall(options) {
+        const args = {
+            group_id: options.groupId,
+            capability_id: options.capabilityId,
+            by: options.by ?? 'user',
+        };
+        if (options.reason)
+            args['reason'] = options.reason;
+        if (options.actorId)
+            args['actor_id'] = options.actorId;
+        return this.call('capability_uninstall', args);
+    }
+    /**
+     * Call one enabled dynamic capability tool through daemon IPC.
+     */
+    async capabilityToolCall(options) {
+        const args = {
+            group_id: options.groupId,
+            tool_name: options.toolName,
+            by: options.by ?? 'user',
+        };
+        if (options.arguments)
+            args['arguments'] = options.arguments;
+        if (options.actorId)
+            args['actor_id'] = options.actorId;
+        return this.call('capability_tool_call', args);
+    }
     // ============================================================
     // Convenience methods: messaging
     // ============================================================
     /**
      * Send a chat message to a group.
      * @param options - Message content, recipients, and priority.
-     * @returns The created event and optional ack event.
+     * @returns The daemon result (includes event id).
      * @throws {DaemonAPIError} On invalid group, missing permissions, etc.
      */
     async send(options) {
@@ -383,8 +663,7 @@ export class CCCCClient {
         return this.call('send', args);
     }
     /**
-     * Send message across groups.
-     * @returns The created event and optional ack event.
+     * Send message across groups
      */
     async sendCrossGroup(options) {
         const args = {
@@ -400,8 +679,7 @@ export class CCCCClient {
         return this.call('send_cross_group', args);
     }
     /**
-     * Reply to a message.
-     * @returns The created event and optional ack event.
+     * Reply message
      */
     async reply(options) {
         const args = {
@@ -416,55 +694,6 @@ export class CCCCClient {
             args['to'] = options.to;
         return this.call('reply', args);
     }
-    /**
-     * Send a message and wait for a reply to it.
-     * Opens the event stream **before** sending to avoid race conditions,
-     * then yields control to the stream until a matching reply arrives.
-     *
-     * @param options - Send options plus `listenAs` (the actor to listen as) and optional `waitTimeoutMs`.
-     * @returns The reply event (a `chat.message` whose `reply_to` matches the sent event ID).
-     * @throws {DaemonAPIError} On send/stream errors.
-     * @throws {Error} If the timeout elapses or the signal is aborted before a reply arrives.
-     */
-    async sendAndWaitForReply(options) {
-        const waitTimeout = options.waitTimeoutMs ?? 60000;
-        const deadline = Date.now() + waitTimeout;
-        // Open stream FIRST (with sinceTs = now) to avoid missing replies
-        // that arrive between send() returning and stream connecting.
-        const stream = this.eventsStream({
-            groupId: options.groupId,
-            by: options.listenAs,
-            kinds: ['chat.message'],
-            sinceTs: new Date().toISOString(),
-            signal: options.signal,
-        });
-        // Now send the message
-        const sendResult = await this.send(options);
-        const sentEventId = sendResult.event.id;
-        try {
-            for await (const item of stream) {
-                if (options.signal?.aborted) {
-                    throw new Error('sendAndWaitForReply aborted');
-                }
-                if (Date.now() > deadline) {
-                    throw new Error(`sendAndWaitForReply timed out after ${waitTimeout}ms`);
-                }
-                if (isStreamEvent(item)) {
-                    const evt = item.event;
-                    if (evt.kind === 'chat.message') {
-                        const data = evt.data;
-                        if (data['reply_to'] === sentEventId) {
-                            return evt;
-                        }
-                    }
-                }
-            }
-        }
-        finally {
-            stream.return(undefined);
-        }
-        throw new Error('sendAndWaitForReply: stream ended without reply');
-    }
     /**
      * Acknowledge chat message
      */
@@ -476,56 +705,6 @@ export class CCCCClient {
             by: by ?? actorId,
         });
     }
-    /**
-     * Send a file as a chat attachment.
-     * @param options - File path (relative to scope root), optional caption and recipients.
-     * @returns The created event and optional ack event.
-     */
-    async fileSend(options) {
-        const args = {
-            group_id: options.groupId,
-            path: options.path,
-            by: options.by ?? 'user',
-            priority: options.priority ?? 'normal',
-            reply_required: options.replyRequired ?? false,
-        };
-        if (options.text)
-            args['text'] = options.text;
-        if (options.to)
-            args['to'] = options.to;
-        return this.call('file_send', args);
-    }
-    /**
-     * Get recent chat messages from the ledger.
-     * @param options - Group ID, limit, and max chars.
-     * @returns The ledger tail result.
-     */
-    async ledgerTail(options) {
-        const args = {
-            group_id: options.groupId,
-            by: options.by ?? 'user',
-        };
-        if (options.limit !== undefined)
-            args['limit'] = options.limit;
-        if (options.maxChars !== undefined)
-            args['max_chars'] = options.maxChars;
-        return this.call('ledger_tail', args);
-    }
-    /**
-     * Get recent terminal output from an actor.
-     * @param options - Group ID, actor ID, and line count.
-     * @returns The terminal tail result.
-     */
-    async terminalTail(options) {
-        const args = {
-            group_id: options.groupId,
-            actor_id: options.actorId,
-            by: options.by ?? 'user',
-        };
-        if (options.lines !== undefined)
-            args['lines'] = options.lines;
-        return this.call('terminal_tail', args);
-    }
     // ============================================================
     // Convenience methods: inbox
     // ============================================================
@@ -598,20 +777,219 @@ export class CCCCClient {
         });
     }
     // ============================================================
+    // Convenience methods: Group Space
+    // ============================================================
+    /**
+     * Read Group Space provider and binding status.
+     */
+    async groupSpaceStatus(options) {
+        return this.call('group_space_status', {
+            group_id: options.groupId,
+            provider: options.provider ?? 'notebooklm',
+        });
+    }
+    /**
+     * List available remote spaces for binding.
+     */
+    async groupSpaceSpaces(options) {
+        return this.call('group_space_spaces', {
+            group_id: options.groupId,
+            provider: options.provider ?? 'notebooklm',
+        });
+    }
+    /**
+     * Read the provider capability matrix for a group.
+     */
+    async groupSpaceCapabilities(options) {
+        return this.call('group_space_capabilities', {
+            group_id: options.groupId,
+            provider: options.provider ?? 'notebooklm',
+        });
+    }
+    /**
+     * Bind or unbind one Group Space lane.
+     */
+    async groupSpaceBind(options) {
+        const args = {
+            group_id: options.groupId,
+            provider: options.provider ?? 'notebooklm',
+            lane: options.lane,
+            action: options.action ?? 'bind',
+            by: options.by ?? 'user',
+        };
+        if (options.remoteSpaceId)
+            args['remote_space_id'] = options.remoteSpaceId;
+        return this.call('group_space_bind', args);
+    }
+    /**
+     * Enqueue one Group Space ingest action.
+     */
+    async groupSpaceIngest(options) {
+        const args = {
+            group_id: options.groupId,
+            provider: options.provider ?? 'notebooklm',
+            lane: options.lane,
+            kind: options.kind ?? 'context_sync',
+            by: options.by ?? 'user',
+        };
+        if (options.payload)
+            args['payload'] = options.payload;
+        if (options.idempotencyKey)
+            args['idempotency_key'] = options.idempotencyKey;
+        return this.call('group_space_ingest', args);
+    }
+    /**
+     * Query Group Space knowledge for one lane.
+     */
+    async groupSpaceQuery(options) {
+        const args = {
+            group_id: options.groupId,
+            provider: options.provider ?? 'notebooklm',
+            lane: options.lane,
+            query: options.query,
+        };
+        if (options.options)
+            args['options'] = options.options;
+        return this.call('group_space_query', args);
+    }
+    /**
+     * Manage remote sources in the bound Group Space lane.
+     */
+    async groupSpaceSources(options) {
+        const args = {
+            group_id: options.groupId,
+            provider: options.provider ?? 'notebooklm',
+            lane: options.lane,
+            action: options.action ?? 'list',
+            by: options.by ?? 'user',
+        };
+        if (options.sourceId)
+            args['source_id'] = options.sourceId;
+        if (options.newTitle)
+            args['new_title'] = options.newTitle;
+        return this.call('group_space_sources', args);
+    }
+    /**
+     * List, generate, or download Group Space artifacts.
+     */
+    async groupSpaceArtifact(options) {
+        const args = {
+            group_id: options.groupId,
+            provider: options.provider ?? 'notebooklm',
+            lane: options.lane,
+            action: options.action ?? 'list',
+            by: options.by ?? 'user',
+        };
+        if (options.kind)
+            args['kind'] = options.kind;
+        if (options.options)
+            args['options'] = options.options;
+        if (options.wait !== undefined)
+            args['wait'] = options.wait;
+        if (options.saveToSpace !== undefined)
+            args['save_to_space'] = options.saveToSpace;
+        if (options.outputPath)
+            args['output_path'] = options.outputPath;
+        if (options.outputFormat)
+            args['output_format'] = options.outputFormat;
+        if (options.artifactId)
+            args['artifact_id'] = options.artifactId;
+        if (options.timeoutSeconds !== undefined)
+            args['timeout_seconds'] = options.timeoutSeconds;
+        if (options.initialInterval !== undefined)
+            args['initial_interval'] = options.initialInterval;
+        if (options.maxInterval !== undefined)
+            args['max_interval'] = options.maxInterval;
+        return this.call('group_space_artifact', args);
+    }
+    /**
+     * List or manage Group Space jobs.
+     */
+    async groupSpaceJobs(options) {
+        const args = {
+            group_id: options.groupId,
+            provider: options.provider ?? 'notebooklm',
+            lane: options.lane,
+            action: options.action ?? 'list',
+            by: options.by ?? 'user',
+        };
+        if (options.jobId)
+            args['job_id'] = options.jobId;
+        if (options.state)
+            args['state'] = options.state;
+        if (options.limit !== undefined)
+            args['limit'] = options.limit;
+        return this.call('group_space_jobs', args);
+    }
+    /**
+     * Read or run Group Space synchronization for one lane.
+     */
+    async groupSpaceSync(options) {
+        return this.call('group_space_sync', {
+            group_id: options.groupId,
+            provider: options.provider ?? 'notebooklm',
+            lane: options.lane,
+            action: options.action ?? 'status',
+            force: options.force ?? false,
+            by: options.by ?? 'user',
+        });
+    }
+    /**
+     * Read provider credential status.
+     */
+    async groupSpaceProviderCredentialStatus(options = {}) {
+        return this.call('group_space_provider_credential_status', {
+            provider: options.provider ?? 'notebooklm',
+            by: options.by ?? 'user',
+        });
+    }
+    /**
+     * Update provider credentials.
+     */
+    async groupSpaceProviderCredentialUpdate(options = {}) {
+        const args = {
+            provider: options.provider ?? 'notebooklm',
+            by: options.by ?? 'user',
+            clear: options.clear ?? false,
+        };
+        if (options.authJson)
+            args['auth_json'] = options.authJson;
+        return this.call('group_space_provider_credential_update', args);
+    }
+    /**
+     * Run provider health check.
+     */
+    async groupSpaceProviderHealthCheck(options = {}) {
+        return this.call('group_space_provider_health_check', {
+            provider: options.provider ?? 'notebooklm',
+            by: options.by ?? 'user',
+        });
+    }
+    /**
+     * Control provider auth flow.
+     */
+    async groupSpaceProviderAuth(options = {}) {
+        const args = {
+            provider: options.provider ?? 'notebooklm',
+            action: options.action ?? 'status',
+            by: options.by ?? 'user',
+        };
+        if (options.timeoutSeconds !== undefined)
+            args['timeout_seconds'] = options.timeoutSeconds;
+        return this.call('group_space_provider_auth', args);
+    }
+    // ============================================================
     // Event stream
     // ============================================================
     /**
      * Subscribe to the group event stream (Server-Sent Events style, long-lived connection).
      * Yields {@link EventStreamItem} objects as they arrive. The socket is destroyed
      * when the generator is returned or thrown.
-     * @param options - Group ID, event filters, optional since cursor, and optional AbortSignal.
+     * @param options - Group ID, event filters, and optional since cursor.
      * @yields {EventStreamItem} Each event or heartbeat from the stream.
      * @throws {DaemonAPIError} If the handshake fails.
      */
     async *eventsStream(options) {
-        // Check abort before connecting
-        if (options.signal?.aborted)
-            return;
         const args = {
             group_id: options.groupId,
             by: options.by ?? 'user',
@@ -637,37 +1015,20 @@ export class CCCCClient {
             socket.destroy();
             throw new DaemonAPIError(handshake.error?.code ?? 'unknown', handshake.error?.message ?? 'Handshake failed', handshake.error?.details, handshake);
         }
-        // Wire up AbortSignal to destroy the socket
-        const onAbort = () => { socket.destroy(); };
-        options.signal?.addEventListener('abort', onAbort, { once: true });
         try {
             for await (const line of readLines(socket, initialBuffer)) {
-                if (options.signal?.aborted)
-                    return;
-                let parsed;
                 try {
-                    parsed = JSON.parse(line);
-                }
-                catch {
-                    // Non-JSON line from daemon; surface as an error so callers know
-                    // something unexpected happened instead of silently losing data.
-                    throw new DaemonAPIError('invalid_stream_data', `Unparseable event stream line: ${line.slice(0, 200)}`, {});
-                }
-                if (parsed !== null && typeof parsed === 'object') {
-                    const obj = parsed;
-                    // Daemon may send error objects in the stream (ok: false).
-                    if ('ok' in obj && obj['ok'] === false) {
-                        const err = obj['error'];
-                        throw new DaemonAPIError(err?.['code'] ?? 'stream_error', err?.['message'] ?? 'Daemon sent error in event stream', err?.['details'] ?? {}, obj);
-                    }
-                    if ('t' in obj) {
+                    const parsed = JSON.parse(line);
+                    if (parsed !== null && typeof parsed === 'object' && 't' in parsed) {
                         yield parsed;
                     }
                 }
+                catch {
+                    // Skip invalid JSON lines.
+                }
             }
         }
         finally {
-            options.signal?.removeEventListener('abort', onAbort);
             socket.destroy();
         }
     }