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

main
ts 286 lines 9.54 KB
Raw
1 import * as datalabeling from "@distilled.cloud/gcp/datalabeling_v1beta1";
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 { GcpEnvironment } from "../Environment.ts";
9 import { createInternalLabels } from "../Labels.ts";
10 import type { Providers } from "../Providers.ts";
11 import {
12 encodeOwnership,
13 findOwned,
14 hasOwnershipMarker,
15 ignoreGone,
16 listAllFeedbackMessages,
17 MAX_FEEDBACK_BODY_LENGTH,
18 noRetryLayer,
19 ownedByAlchemy,
20 parseOwnership,
21 parseResourceName,
22 replaceOnIdentity,
23 retryDelete,
24 retryTransient,
25 sameText,
26 waitForVisible,
27 waitUntilGone,
28 } from "./internal.ts";
29 import { resourceNameFromOperation, waitForOperation } from "./operations.ts";
30
31 export type DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessageProps = {
32 /**
33 * Parent feedback thread resource name
34 * `projects/{project}/datasets/{dataset}/annotatedDatasets/{annotatedDataset}/feedbackThreads/{feedbackThread}`.
35 * Immutable — changing it replaces the message.
36 */
37 parent: string;
38 /**
39 * Feedback message id (the last path segment). Server-assigned on
40 * create. Immutable — changing it replaces the message.
41 */
42 feedbackMessageId?: string;
43 /**
44 * String content of the feedback. Maximum 10,000 characters. Messages
45 * have no labels field, so Alchemy stamps ownership into this field.
46 * Immutable — changing it replaces the message.
47 */
48 body?: string;
49 /**
50 * Image payload for this feedback, if the comment is an image.
51 * Immutable — changing it replaces the message.
52 */
53 image?: string;
54 };
55
56 export type DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage = Resource<
57 "GCP.DataLabeling.DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage",
58 DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessageProps,
59 {
60 /**
61 * Full resource name
62 * `.../feedbackThreads/{thread}/feedbackMessages/{message}`.
63 */
64 name: string;
65 /** Feedback message id (last path segment). */
66 feedbackMessageId: string;
67 /** Parent feedback thread resource name. */
68 parent: string;
69 /** Project id. */
70 project: string;
71 /** Dataset id. */
72 datasetId: string;
73 /** User body with the Alchemy ownership prefix stripped. */
74 body: string | undefined;
75 /** Image payload, if any. */
76 image: string | undefined;
77 /** RFC3339 creation timestamp. */
78 createTime: string | undefined;
79 },
80 never,
81 Providers
82 >;
83
84 /**
85 * A Data Labeling feedback message on a labeling-task feedback thread.
86 *
87 * Create is a long-running operation. Message ids are server-assigned.
88 * Parent thread, body, and image are immutable — changing them replaces
89 * the message. There is no labels API, so Alchemy stamps ownership into
90 * `body` so `list` / nuke can find them.
91 *
92 * ### Creating a Feedback Message
93 * **Example:** Text comment on a thread
94 * ```typescript
95 * const message = yield* GCP.DataLabeling.DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage(
96 * "Note",
97 * {
98 * parent: threadName,
99 * body: "please relabel the occluded boxes",
100 * },
101 * );
102 * ```
103 *
104 * **Example:** Ownership-only body
105 * ```typescript
106 * const message = yield* GCP.DataLabeling.DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage(
107 * "Note",
108 * {
109 * parent: threadName,
110 * },
111 * );
112 * ```
113 *
114 * @resource
115 * @category DataLabeling
116 */
117 export const DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage =
118 Resource<DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage>(
119 "GCP.DataLabeling.DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage",
120 );
121
122 export class DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessageNotResolved extends Data.TaggedError(
123 "GCP.DataLabeling.DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessageNotResolved",
124 )<{
125 resourceName: string;
126 }> {}
127
128 const resourceNameOf = (parent: string, feedbackMessageId: string) =>
129 `${parent}/feedbackMessages/${feedbackMessageId}`;
130
131 const expandParent = (parent: string, project: string) =>
132 parent.includes("/")
133 ? parent.replace(/\/+$/, "")
134 : `projects/${project}/datasets/_/annotatedDatasets/_/feedbackThreads/${parent}`;
135
136 const toAttrs = (
137 message: datalabeling.GoogleCloudDatalabelingV1beta1FeedbackMessage,
138 project: string,
139 ) => {
140 const name = message.name ?? "";
141 const parsed = parseResourceName(
142 name.replace(/\/feedbackMessage\//, "/feedbackMessages/"),
143 "feedbackMessages",
144 );
145 const fallback = parseResourceName(name, "feedbackMessage");
146 const collection = parsed.id.length > 0 ? parsed : fallback;
147 return {
148 name,
149 feedbackMessageId: collection.id,
150 parent: collection.parent,
151 project: collection.project || project,
152 datasetId: collection.datasetId,
153 body: parseOwnership(message.body).text,
154 image: message.image,
155 createTime: message.createTime,
156 };
157 };
158
159 const getByName = (name: string) =>
160 name.length === 0
161 ? Effect.undefined
162 : datalabeling
163 .getProjectsDatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessages({
164 name,
165 })
166 .pipe(
167 Effect.provide(noRetryLayer),
168 Effect.catchTags({
169 NotFound: () => Effect.undefined,
170 BadGateway: () => Effect.undefined,
171 }),
172 );
173
174 const findByOwnership = (id: string, project: string) =>
175 Effect.gen(function* () {
176 const rows = yield* listAllFeedbackMessages(project);
177 return yield* findOwned(id, rows, (row) => row.body);
178 });
179
180 export const DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessageProvider = () =>
181 Provider.succeed(DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessage, {
182 stables: ["name", "feedbackMessageId", "parent", "project", "datasetId", "createTime"],
183
184 diff: Effect.fn(function* ({ news, olds, output }) {
185 if (!isResolved(news)) return undefined;
186 const extra =
187 (olds !== undefined && !sameText(news.body, output?.body)) ||
188 (output !== undefined && !sameText(news.image, output.image));
189 return replaceOnIdentity({
190 previousId: olds?.feedbackMessageId ?? output?.feedbackMessageId,
191 nextId: news.feedbackMessageId,
192 previousParent: olds?.parent ?? output?.parent,
193 nextParent: news.parent,
194 extra,
195 });
196 }),
197
198 read: Effect.fn(function* ({ id, olds, output }) {
199 const env = yield* GcpEnvironment.current;
200 const parent =
201 olds?.parent !== undefined
202 ? expandParent(olds.parent, env.project)
203 : (output?.parent ?? "");
204 const feedbackMessageId =
205 olds?.feedbackMessageId ??
206 output?.feedbackMessageId ??
207 (output?.name
208 ? parseResourceName(
209 output.name.replace(/\/feedbackMessage\//, "/feedbackMessages/"),
210 "feedbackMessages",
211 ).id
212 : "");
213 const name =
214 output?.name ??
215 (parent.length > 0 && feedbackMessageId.length > 0
216 ? resourceNameOf(parent, feedbackMessageId)
217 : "");
218 const existing = (yield* getByName(name)) ?? (yield* findByOwnership(id, env.project));
219 if (existing === undefined) return undefined;
220 const attrs = toAttrs(existing, env.project);
221 return (yield* ownedByAlchemy(id, existing.body)) ? attrs : Unowned(attrs);
222 }),
223
224 list: () =>
225 Effect.gen(function* () {
226 const env = yield* GcpEnvironment.current;
227 const rows = yield* listAllFeedbackMessages(env.project);
228 return rows
229 .filter((row) => hasOwnershipMarker(row.body))
230 .map((row) => toAttrs(row, env.project));
231 }),
232
233 reconcile: Effect.fn(function* ({ id, news, output }) {
234 const env = yield* GcpEnvironment.current;
235 const parent = expandParent(news.parent, env.project);
236 const feedbackMessageId = news.feedbackMessageId ?? output?.feedbackMessageId;
237 const name =
238 output?.name ??
239 (feedbackMessageId !== undefined ? resourceNameOf(parent, feedbackMessageId) : "");
240 const ownership = yield* createInternalLabels(id);
241 const body = encodeOwnership(ownership, news.body, MAX_FEEDBACK_BODY_LENGTH);
242
243 let current = (yield* getByName(name)) ?? (yield* findByOwnership(id, env.project));
244
245 if (current === undefined) {
246 const created = yield* retryTransient(
247 datalabeling.createProjectsDatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessages({
248 parent,
249 body: {
250 body,
251 image: news.image,
252 requesterFeedbackMetadata: {},
253 },
254 }),
255 ).pipe(Effect.catchTag("Conflict", () => Effect.undefined));
256 if (created !== undefined) {
257 const done = yield* waitForOperation(created);
258 const createdName = resourceNameFromOperation(done);
259 if (createdName !== undefined) {
260 current = yield* waitForVisible(getByName(createdName));
261 }
262 }
263 if (current === undefined) {
264 current = yield* findByOwnership(id, env.project);
265 }
266 }
267
268 if (current === undefined) {
269 return yield* new DatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessageNotResolved({
270 resourceName: name || parent,
271 });
272 }
273
274 return toAttrs(current, env.project);
275 }),
276
277 delete: Effect.fn(function* ({ output }) {
278 if (!output.name) return;
279 yield* datalabeling
280 .deleteProjectsDatasetsAnnotatedDatasetsFeedbackThreadsFeedbackMessages({
281 name: output.name,
282 })
283 .pipe(retryDelete, ignoreGone);
284 yield* waitUntilGone(getByName(output.name));
285 }),
286 });