@zhin.js/service-activity-feedback 1.0.0

package/src/index.ts

@@ -0,0 +1,41 @@
+/**
+ * @zhin.js/service-activity-feedback
+ */
+import { usePlugin } from 'zhin.js';
+import {
+  createActivityFeedbackOrchestratorFromPlugin,
+  mountActivityFeedbackService,
+} from './ai-event-binder.js';
+import { loadActivityFeedbackServiceConfig, type ActivityFeedbackServiceConfig } from './config.js';
+
+const plugin = usePlugin();
+const { root, logger } = plugin;
+
+const configService = root.inject('config');
+const appConfig = configService?.getPrimary<{ activityFeedback?: ActivityFeedbackServiceConfig }>() || {};
+const serviceConfig = loadActivityFeedbackServiceConfig(appConfig.activityFeedback);
+
+if (serviceConfig.enabled !== false) {
+  mountActivityFeedbackService(
+    plugin,
+    createActivityFeedbackOrchestratorFromPlugin(plugin, serviceConfig),
+  );
+} else {
+  logger.info('[ActivityFeedback] disabled by activityFeedback.enabled=false');
+}
+
+export {
+  bindActivityFeedbackToAIEvents,
+  createActivityFeedbackOrchestrator,
+  createActivityFeedbackOrchestratorFromPlugin,
+  mountActivityFeedbackService,
+} from './ai-event-binder.js';
+export { ActivityFeedbackOrchestrator } from './orchestrator.js';
+export { ActivityFeedbackPolicy } from './policy.js';
+export {
+  loadActivityFeedbackServiceConfig,
+  resolveActivityFeedbackForTarget,
+  type ActivityFeedbackServiceConfig,
+} from './config.js';
+export type { ActivityFeedbackEndpointAccess } from './executor.js';
+export default plugin;

package/src/orchestrator.ts

@@ -0,0 +1,55 @@
+import {
+  toActivityFeedbackEventContext,
+  type AIEventPayload,
+  type ActivityFeedbackPhase,
+} from '@zhin.js/agent';
+import { ActivityFeedbackExecutor } from './executor.js';
+import { ActivityFeedbackPolicy } from './policy.js';
+
+type Logger = { debug: (msg: string, ...args: unknown[]) => void; error: (msg: string, ...args: unknown[]) => void };
+
+export class ActivityFeedbackOrchestrator {
+  constructor(
+    private readonly policy: ActivityFeedbackPolicy,
+    private readonly executor: ActivityFeedbackExecutor,
+    private readonly log: Logger,
+  ) {}
+
+  async startPhase(payload: AIEventPayload, phase: ActivityFeedbackPhase, reason: string): Promise<void> {
+    const ctx = toActivityFeedbackEventContext(payload);
+    if (!ctx) return;
+
+    try {
+      const resolution = this.policy.resolvePhase(ctx.platform, ctx.endpointId, phase, ctx.sceneType);
+      if (resolution.kind !== 'active') return;
+
+      this.log.debug(`[ActivityFeedback] start ${phase} (${reason}) session=${ctx.sessionId}`);
+      await this.executor.start(ctx, phase, resolution.config);
+    } catch (error) {
+      this.log.error(`[ActivityFeedback] start ${phase} failed (${reason}):`, error);
+    }
+  }
+
+  async stopPhase(payload: AIEventPayload, phase: ActivityFeedbackPhase, reason: string): Promise<void> {
+    const ctx = toActivityFeedbackEventContext(payload);
+    if (!ctx) return;
+
+    try {
+      this.log.debug(`[ActivityFeedback] stop ${phase} (${reason}) session=${ctx.sessionId}`);
+      await this.executor.stop(ctx, phase);
+    } catch (error) {
+      this.log.error(`[ActivityFeedback] stop ${phase} failed (${reason}):`, error);
+    }
+  }
+
+  async updateThinkingText(payload: AIEventPayload, text: string): Promise<void> {
+    const ctx = toActivityFeedbackEventContext(payload);
+    if (!ctx || !text) return;
+
+    try {
+      await this.executor.updateThinkingText(ctx, text);
+    } catch (error) {
+      this.log.error('[ActivityFeedback] thinking update failed:', error);
+    }
+  }
+}

package/src/policy.ts

@@ -0,0 +1,51 @@
+import {
+  resolveActivityFeedbackPhaseConfig,
+  type ActivityFeedbackPhase,
+  type ActivitySceneType,
+  type ResolvedActivityFeedbackPhaseConfig,
+} from '@zhin.js/agent';
+import {
+  type ActivityFeedbackServiceConfig,
+  mergeActivityFeedbackLayers,
+  loadActivityFeedbackServiceConfig,
+} from './config.js';
+
+export type { ActivityFeedbackServiceConfig } from './config.js';
+export { loadActivityFeedbackServiceConfig, resolveActivityFeedbackForTarget } from './config.js';
+
+export type PhaseResolution =
+  | { kind: 'disabled' }
+  | { kind: 'none' }
+  | { kind: 'active'; config: ResolvedActivityFeedbackPhaseConfig };
+
+export class ActivityFeedbackPolicy {
+  constructor(private readonly service: ActivityFeedbackServiceConfig) {}
+
+  resolvePhase(
+    platform: string,
+    endpointId: string,
+    phase: ActivityFeedbackPhase,
+    sceneType: ActivitySceneType,
+  ): PhaseResolution {
+    if (this.service.enabled === false) {
+      return { kind: 'disabled' };
+    }
+
+    const policy = mergeActivityFeedbackLayers(
+      this.service.defaults,
+      this.service.platforms?.[platform],
+      this.service.endpoints?.[`${platform}:${endpointId}`],
+    );
+
+    if (policy?.enabled === false) {
+      return { kind: 'disabled' };
+    }
+
+    const config = resolveActivityFeedbackPhaseConfig(platform, policy, phase, sceneType);
+    if (config.type === 'none') {
+      return { kind: 'none' };
+    }
+
+    return { kind: 'active', config };
+  }
+}