The best way to control Claude Code, Codex and more from any computer or phone

main
ts 290 lines 9.81 KB
Raw
1 import * as cci from "@distilled.cloud/gcp/contactcenterinsights_v1";
2 import { Unowned } from "alchemy/AdoptPolicy";
3 import { isResolved } from "alchemy/Diff";
4 import * as Provider from "alchemy/Provider";
5 import { Resource } from "alchemy/Resource";
6 import * as Data from "effect/Data";
7 import * as Effect from "effect/Effect";
8 import * as Stream from "effect/Stream";
9 import { GcpEnvironment } from "../Environment.ts";
10 import { createInternalLabels } from "../Labels.ts";
11 import type { Providers } from "../Providers.ts";
12 import {
13 encodeOwnershipLine,
14 hasOwnershipMarker,
15 lastSegment,
16 locationOf,
17 locationParent,
18 ownedByAlchemy,
19 parentOf,
20 parseOwnership,
21 sameJson,
22 } from "./ownership.ts";
23
24 type AgentInfo = {
25 /** User-specified agent identifier. */
26 agentId?: string;
27 /**
28 * Agent display name. Assessments have no labels field, so Alchemy
29 * ownership is stored in a `[alchemy …]` prefix on this field and
30 * stripped from attributes.
31 */
32 displayName?: string;
33 /** Agent type (`HUMAN_AGENT`, `AUTOMATED_AGENT`, …). */
34 agentType?: "ROLE_UNSPECIFIED" | "HUMAN_AGENT" | "AUTOMATED_AGENT" | "END_USER" | "ANY_AGENT";
35 /** Deprecated team string. Prefer `teams`. */
36 team?: string;
37 /** Team names. */
38 teams?: string[];
39 /** Agent location. */
40 location?: string;
41 /** Outcome of the agent's segment of the call. */
42 dispositionCode?: string;
43 /** Automated-agent deployment id. */
44 deploymentId?: string;
45 /** Automated-agent deployment display name. */
46 deploymentDisplayName?: string;
47 /** Automated-agent version id. */
48 versionId?: string;
49 /** Automated-agent version display name. */
50 versionDisplayName?: string;
51 /** Entry subagent id. */
52 entrySubagentId?: string;
53 /** Entry subagent display name. */
54 entrySubagentDisplayName?: string;
55 };
56
57 export type ConversationsAssessmentProps = {
58 /**
59 * Parent Conversation resource name
60 * (`projects/{project}/locations/{location}/conversations/{conversation}`).
61 * Immutable — changing it replaces the assessment.
62 */
63 parent: string;
64 /**
65 * Agent the assessment is for. Assessments have no update RPC; changing
66 * agent info replaces the assessment.
67 */
68 agentInfo?: AgentInfo;
69 };
70
71 export type ConversationsAssessment = Resource<
72 "GCP.ContactCenterInsights.ConversationsAssessment",
73 ConversationsAssessmentProps,
74 {
75 /** Full resource name. */
76 name: string;
77 /** Assessment id (last path segment). */
78 assessmentId: string;
79 /** Parent conversation resource name. */
80 parent: string;
81 /** Region id. */
82 location: string;
83 /** Project id. */
84 project: string;
85 /** Agent info with the Alchemy ownership prefix stripped from displayName. */
86 agentInfo: AgentInfo | undefined;
87 /** Server-reported assessment state. */
88 state: string | undefined;
89 /** RFC3339 creation timestamp. */
90 createTime: string | undefined;
91 /** RFC3339 last-update timestamp. */
92 updateTime: string | undefined;
93 },
94 never,
95 Providers
96 >;
97
98 /**
99 * A quality assessment of a Contact Center Insights conversation.
100 *
101 * Parent conversation and agent info are immutable — there is no update
102 * RPC, so changing either replaces the assessment. Assessments have no
103 * labels field; Alchemy stamps ownership into `agentInfo.displayName`.
104 *
105 * ### Creating an Assessment
106 * **Example:** Human-agent assessment
107 * ```typescript
108 * const assessment = yield* GCP.ContactCenterInsights.ConversationsAssessment(
109 * "QA",
110 * {
111 * parent: conversation.name,
112 * agentInfo: { agentId: "agent-1", displayName: "Ada", agentType: "HUMAN_AGENT" },
113 * },
114 * );
115 * ```
116 *
117 * @resource
118 * @category ContactCenterInsights
119 */
120 export const ConversationsAssessment = Resource<ConversationsAssessment>(
121 "GCP.ContactCenterInsights.ConversationsAssessment",
122 );
123
124 export class ConversationsAssessmentNotResolved extends Data.TaggedError(
125 "GCP.ContactCenterInsights.ConversationsAssessmentNotResolved",
126 )<{
127 resourceName: string;
128 }> {}
129
130 const toAgentInfo = (
131 info:
132 | cci.GoogleCloudContactcenterinsightsV1ConversationQualityMetadataAgentInfo
133 | AgentInfo
134 | undefined,
135 stripOwnership: boolean,
136 ): AgentInfo | undefined => {
137 if (info === undefined) return undefined;
138 const displayName = stripOwnership ? parseOwnership(info.displayName).text : info.displayName;
139 return {
140 agentId: info.agentId,
141 displayName,
142 agentType: info.agentType as AgentInfo["agentType"],
143 team: info.team,
144 teams: info.teams,
145 location: info.location,
146 dispositionCode: info.dispositionCode,
147 deploymentId: info.deploymentId,
148 deploymentDisplayName: info.deploymentDisplayName,
149 versionId: info.versionId,
150 versionDisplayName: info.versionDisplayName,
151 entrySubagentId: info.entrySubagentId,
152 entrySubagentDisplayName: info.entrySubagentDisplayName,
153 };
154 };
155
156 const encodeAgentInfo = (
157 info: AgentInfo | undefined,
158 ownership: Record<string, string>,
159 ): cci.GoogleCloudContactcenterinsightsV1ConversationQualityMetadataAgentInfo => ({
160 ...info,
161 displayName: encodeOwnershipLine(ownership, info?.displayName, 256),
162 });
163
164 const toAttrs = (assessment: cci.GoogleCloudContactcenterinsightsV1Assessment, project: string) => {
165 const name = assessment.name ?? "";
166 return {
167 name,
168 assessmentId: lastSegment(name),
169 parent: parentOf(name),
170 location: locationOf(name),
171 project,
172 agentInfo: toAgentInfo(assessment.agentInfo, true),
173 state: assessment.state,
174 createTime: assessment.createTime,
175 updateTime: assessment.updateTime,
176 };
177 };
178
179 const getByName = (name: string) =>
180 name.length === 0
181 ? Effect.undefined
182 : cci
183 .getProjectsLocationsConversationsAssessments({ name })
184 .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
185
186 const listAtParent = (parent: string, project: string) =>
187 cci.listProjectsLocationsConversationsAssessments.pages({ parent, pageSize: 100 }).pipe(
188 Stream.flatMap((page) => Stream.fromIterable(page.assessments ?? [])),
189 Stream.filter((assessment) => hasOwnershipMarker(assessment.agentInfo?.displayName)),
190 Stream.map((assessment) => toAttrs(assessment, project)),
191 Stream.runCollect,
192 Effect.map((chunk) => Array.from(chunk)),
193 Effect.catchTag("NotFound", () => Effect.succeed([])),
194 );
195
196 const findOwned = (parent: string, displayName: string) =>
197 cci.listProjectsLocationsConversationsAssessments.pages({ parent, pageSize: 100 }).pipe(
198 Stream.flatMap((page) => Stream.fromIterable(page.assessments ?? [])),
199 Stream.filter((assessment) => assessment.agentInfo?.displayName === displayName),
200 Stream.runHead,
201 Effect.map((option) => (option._tag === "Some" ? option.value : undefined)),
202 Effect.catchTag("NotFound", () => Effect.undefined),
203 );
204
205 export const ConversationsAssessmentProvider = () =>
206 Provider.succeed(ConversationsAssessment, {
207 stables: ["name", "assessmentId", "parent", "location", "project", "createTime"],
208
209 diff: Effect.fn(function* ({ news, olds, output }) {
210 if (!isResolved(news)) return undefined;
211 const previousParent = olds?.parent ?? output?.parent;
212 if (previousParent !== undefined && news.parent !== previousParent) {
213 return { action: "replace" as const, deleteFirst: false };
214 }
215 const previousAgent = olds?.agentInfo ?? output?.agentInfo;
216 if (
217 previousAgent !== undefined &&
218 !sameJson(toAgentInfo(previousAgent, false), toAgentInfo(news.agentInfo, false))
219 ) {
220 return { action: "replace" as const, deleteFirst: false };
221 }
222 return undefined;
223 }),
224
225 read: Effect.fn(function* ({ id, olds, output }) {
226 const env = yield* GcpEnvironment.current;
227 const existing = yield* getByName(output?.name ?? "");
228 if (existing !== undefined) {
229 const attrs = toAttrs(existing, env.project);
230 return (yield* ownedByAlchemy(id, existing.agentInfo?.displayName))
231 ? attrs
232 : Unowned(attrs);
233 }
234 if (olds?.parent === undefined) return undefined;
235 const ownership = yield* createInternalLabels(id);
236 const displayName = encodeOwnershipLine(ownership, olds.agentInfo?.displayName);
237 const found = yield* findOwned(olds.parent, displayName);
238 if (found === undefined) return undefined;
239 const attrs = toAttrs(found, env.project);
240 return (yield* ownedByAlchemy(id, found.agentInfo?.displayName)) ? attrs : Unowned(attrs);
241 }),
242
243 list: () =>
244 Effect.gen(function* () {
245 const env = yield* GcpEnvironment.current;
246 return yield* listAtParent(
247 `${locationParent(env.project, env.region)}/conversations/-`,
248 env.project,
249 );
250 }),
251
252 reconcile: Effect.fn(function* ({ id, news, output }) {
253 const env = yield* GcpEnvironment.current;
254 const ownership = yield* createInternalLabels(id);
255 const desiredAgent = encodeAgentInfo(news.agentInfo, ownership);
256 const displayName = desiredAgent.displayName ?? "";
257
258 let current = yield* getByName(output?.name ?? "");
259 if (current === undefined) {
260 current = yield* findOwned(news.parent, displayName);
261 }
262
263 if (current === undefined) {
264 const created = yield* cci
265 .createProjectsLocationsConversationsAssessments({
266 parent: news.parent,
267 body: { agentInfo: desiredAgent },
268 })
269 .pipe(Effect.catchTag("Conflict", () => Effect.undefined));
270 current = created ?? (yield* findOwned(news.parent, displayName));
271 }
272
273 if (current === undefined) {
274 return yield* new ConversationsAssessmentNotResolved({
275 resourceName: output?.name ?? `${news.parent}/assessments/-`,
276 });
277 }
278
279 return toAttrs(current, env.project);
280 }),
281
282 delete: Effect.fn(function* ({ output }) {
283 yield* cci
284 .deleteProjectsLocationsConversationsAssessments({
285 name: output.name,
286 force: true,
287 })
288 .pipe(Effect.catchTag("NotFound", () => Effect.void));
289 }),
290 });