feat(planning): grille hebdomadaire complète avec API et filtres
- Connexion API via proxy Angular (résolution CORS, base path /api) - Import CSS ng-zorro global pour les modales et composants - Filtres Camion/Show câblés sur l'affichage de la grille - Camions affichés via TrucksService (linkés au show du même créneau) - Panneau de détails : spectacles + camions du jour sélectionné - Modale de création de spectacle stylisée avec fond et centrage - Positionnement précis des events à la minute dans leur créneau - Auto-scroll vers l'heure courante au chargement - Ligne "maintenant" sur la colonne du jour actuel - Régénération des services OpenAPI (nouveaux noms de types) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
+16
-230
@@ -1,9 +1,7 @@
|
||||
import { AnySchema, AnyObjectSchema, SchemaOutput } from '../server/zod-compat.js';
|
||||
import { ClientCapabilities, GetTaskRequest, GetTaskPayloadRequest, ListTasksResultSchema, CancelTaskResultSchema, JSONRPCRequest, Progress, RequestId, Result, ServerCapabilities, RequestMeta, RequestInfo, GetTaskResult, TaskCreationParams, RelatedTaskMetadata, Task, Request, Notification } from '../types.js';
|
||||
import { Transport, TransportSendOptions } from './transport.js';
|
||||
import { AuthInfo } from '../server/auth/types.js';
|
||||
import { TaskStore, TaskMessageQueue, CreateTaskOptions } from '../experimental/tasks/interfaces.js';
|
||||
import { ResponseMessage } from './responseMessage.js';
|
||||
import { ZodLiteral, ZodObject, ZodType, z } from "zod";
|
||||
import { ClientCapabilities, JSONRPCRequest, Notification, Progress, Request, RequestId, Result, ServerCapabilities, RequestMeta, RequestInfo } from "../types.js";
|
||||
import { Transport, TransportSendOptions } from "./transport.js";
|
||||
import { AuthInfo } from "../server/auth/types.js";
|
||||
/**
|
||||
* Callback for progress notifications.
|
||||
*/
|
||||
@@ -27,29 +25,6 @@ export type ProtocolOptions = {
|
||||
* e.g., ['notifications/tools/list_changed']
|
||||
*/
|
||||
debouncedNotificationMethods?: string[];
|
||||
/**
|
||||
* Optional task storage implementation. If provided, enables task-related request handlers
|
||||
* and provides task storage capabilities to request handlers.
|
||||
*/
|
||||
taskStore?: TaskStore;
|
||||
/**
|
||||
* Optional task message queue implementation for managing server-initiated messages
|
||||
* that will be delivered through the tasks/result response stream.
|
||||
*/
|
||||
taskMessageQueue?: TaskMessageQueue;
|
||||
/**
|
||||
* Default polling interval (in milliseconds) for task status checks when no pollInterval
|
||||
* is provided by the server. Defaults to 5000ms if not specified.
|
||||
*/
|
||||
defaultTaskPollInterval?: number;
|
||||
/**
|
||||
* Maximum number of messages that can be queued per task for side-channel delivery.
|
||||
* If undefined, the queue size is unbounded.
|
||||
* When the limit is exceeded, the TaskMessageQueue implementation's enqueue() method
|
||||
* will throw an error. It's the implementation's responsibility to handle overflow
|
||||
* appropriately (e.g., by failing the task, dropping messages, etc.).
|
||||
*/
|
||||
maxTaskQueueSize?: number;
|
||||
};
|
||||
/**
|
||||
* The default request timeout, in miliseconds.
|
||||
@@ -61,8 +36,6 @@ export declare const DEFAULT_REQUEST_TIMEOUT_MSEC = 60000;
|
||||
export type RequestOptions = {
|
||||
/**
|
||||
* If set, requests progress notifications from the remote end (if supported). When progress notifications are received, this callback will be invoked.
|
||||
*
|
||||
* For task-augmented requests: progress notifications continue after CreateTaskResult is returned and stop automatically when the task reaches a terminal status.
|
||||
*/
|
||||
onprogress?: ProgressCallback;
|
||||
/**
|
||||
@@ -87,14 +60,6 @@ export type RequestOptions = {
|
||||
* If not specified, there is no maximum total timeout.
|
||||
*/
|
||||
maxTotalTimeout?: number;
|
||||
/**
|
||||
* If provided, augments the request with task creation parameters to enable call-now, fetch-later execution patterns.
|
||||
*/
|
||||
task?: TaskCreationParams;
|
||||
/**
|
||||
* If provided, associates this request with a related task.
|
||||
*/
|
||||
relatedTask?: RelatedTaskMetadata;
|
||||
} & TransportSendOptions;
|
||||
/**
|
||||
* Options that can be given per notification.
|
||||
@@ -104,69 +69,7 @@ export type NotificationOptions = {
|
||||
* May be used to indicate to the transport which incoming request to associate this outgoing notification with.
|
||||
*/
|
||||
relatedRequestId?: RequestId;
|
||||
/**
|
||||
* If provided, associates this notification with a related task.
|
||||
*/
|
||||
relatedTask?: RelatedTaskMetadata;
|
||||
};
|
||||
/**
|
||||
* Options that can be given per request.
|
||||
*/
|
||||
export type TaskRequestOptions = Omit<RequestOptions, 'relatedTask'>;
|
||||
/**
|
||||
* Request-scoped TaskStore interface.
|
||||
*/
|
||||
export interface RequestTaskStore {
|
||||
/**
|
||||
* Creates a new task with the given creation parameters.
|
||||
* The implementation generates a unique taskId and createdAt timestamp.
|
||||
*
|
||||
* @param taskParams - The task creation parameters from the request
|
||||
* @returns The created task object
|
||||
*/
|
||||
createTask(taskParams: CreateTaskOptions): Promise<Task>;
|
||||
/**
|
||||
* Gets the current status of a task.
|
||||
*
|
||||
* @param taskId - The task identifier
|
||||
* @returns The task object
|
||||
* @throws If the task does not exist
|
||||
*/
|
||||
getTask(taskId: string): Promise<Task>;
|
||||
/**
|
||||
* Stores the result of a task and sets its final status.
|
||||
*
|
||||
* @param taskId - The task identifier
|
||||
* @param status - The final status: 'completed' for success, 'failed' for errors
|
||||
* @param result - The result to store
|
||||
*/
|
||||
storeTaskResult(taskId: string, status: 'completed' | 'failed', result: Result): Promise<void>;
|
||||
/**
|
||||
* Retrieves the stored result of a task.
|
||||
*
|
||||
* @param taskId - The task identifier
|
||||
* @returns The stored result
|
||||
*/
|
||||
getTaskResult(taskId: string): Promise<Result>;
|
||||
/**
|
||||
* Updates a task's status (e.g., to 'cancelled', 'failed', 'completed').
|
||||
*
|
||||
* @param taskId - The task identifier
|
||||
* @param status - The new status
|
||||
* @param statusMessage - Optional diagnostic message for failed tasks or other status information
|
||||
*/
|
||||
updateTaskStatus(taskId: string, status: Task['status'], statusMessage?: string): Promise<void>;
|
||||
/**
|
||||
* Lists tasks, optionally starting from a pagination cursor.
|
||||
*
|
||||
* @param cursor - Optional cursor for pagination
|
||||
* @returns An object containing the tasks array and an optional nextCursor
|
||||
*/
|
||||
listTasks(cursor?: string): Promise<{
|
||||
tasks: Task[];
|
||||
nextCursor?: string;
|
||||
}>;
|
||||
}
|
||||
/**
|
||||
* Extra data given to request handlers.
|
||||
*/
|
||||
@@ -192,9 +95,6 @@ export type RequestHandlerExtra<SendRequestT extends Request, SendNotificationT
|
||||
* This can be useful for tracking or logging purposes.
|
||||
*/
|
||||
requestId: RequestId;
|
||||
taskId?: string;
|
||||
taskStore?: RequestTaskStore;
|
||||
taskRequestedTtl?: number | null;
|
||||
/**
|
||||
* The original HTTP request.
|
||||
*/
|
||||
@@ -210,19 +110,7 @@ export type RequestHandlerExtra<SendRequestT extends Request, SendNotificationT
|
||||
*
|
||||
* This is used by certain transports to correctly associate related messages.
|
||||
*/
|
||||
sendRequest: <U extends AnySchema>(request: SendRequestT, resultSchema: U, options?: TaskRequestOptions) => Promise<SchemaOutput<U>>;
|
||||
/**
|
||||
* Closes the SSE stream for this request, triggering client reconnection.
|
||||
* Only available when using StreamableHTTPServerTransport with eventStore configured.
|
||||
* Use this to implement polling behavior during long-running operations.
|
||||
*/
|
||||
closeSSEStream?: () => void;
|
||||
/**
|
||||
* Closes the standalone GET SSE stream, triggering client reconnection.
|
||||
* Only available when using StreamableHTTPServerTransport with eventStore configured.
|
||||
* Use this to implement polling behavior for server-initiated notifications.
|
||||
*/
|
||||
closeStandaloneSSEStream?: () => void;
|
||||
sendRequest: <U extends ZodType<object>>(request: SendRequestT, resultSchema: U, options?: RequestOptions) => Promise<z.infer<U>>;
|
||||
};
|
||||
/**
|
||||
* Implements MCP protocol framing on top of a pluggable transport, including
|
||||
@@ -239,10 +127,6 @@ export declare abstract class Protocol<SendRequestT extends Request, SendNotific
|
||||
private _progressHandlers;
|
||||
private _timeoutInfo;
|
||||
private _pendingDebouncedNotifications;
|
||||
private _taskProgressTokens;
|
||||
private _taskStore?;
|
||||
private _taskMessageQueue?;
|
||||
private _requestResolvers;
|
||||
/**
|
||||
* Callback for when the connection is closed for any reason.
|
||||
*
|
||||
@@ -264,7 +148,6 @@ export declare abstract class Protocol<SendRequestT extends Request, SendNotific
|
||||
*/
|
||||
fallbackNotificationHandler?: (notification: Notification) => Promise<void>;
|
||||
constructor(_options?: ProtocolOptions | undefined);
|
||||
private _oncancel;
|
||||
private _setupTimeout;
|
||||
private _resetTimeout;
|
||||
private _cleanupTimeout;
|
||||
@@ -290,13 +173,13 @@ export declare abstract class Protocol<SendRequestT extends Request, SendNotific
|
||||
*
|
||||
* This should be implemented by subclasses.
|
||||
*/
|
||||
protected abstract assertCapabilityForMethod(method: SendRequestT['method']): void;
|
||||
protected abstract assertCapabilityForMethod(method: SendRequestT["method"]): void;
|
||||
/**
|
||||
* A method to check if a notification is supported by the local side, for the given method to be sent.
|
||||
*
|
||||
* This should be implemented by subclasses.
|
||||
*/
|
||||
protected abstract assertNotificationCapability(method: SendNotificationT['method']): void;
|
||||
protected abstract assertNotificationCapability(method: SendNotificationT["method"]): void;
|
||||
/**
|
||||
* A method to check if a request handler is supported by the local side, for the given method to be handled.
|
||||
*
|
||||
@@ -304,79 +187,11 @@ export declare abstract class Protocol<SendRequestT extends Request, SendNotific
|
||||
*/
|
||||
protected abstract assertRequestHandlerCapability(method: string): void;
|
||||
/**
|
||||
* A method to check if task creation is supported for the given request method.
|
||||
*
|
||||
* This should be implemented by subclasses.
|
||||
*/
|
||||
protected abstract assertTaskCapability(method: string): void;
|
||||
/**
|
||||
* A method to check if task handler is supported by the local side, for the given method to be handled.
|
||||
*
|
||||
* This should be implemented by subclasses.
|
||||
*/
|
||||
protected abstract assertTaskHandlerCapability(method: string): void;
|
||||
/**
|
||||
* Sends a request and returns an AsyncGenerator that yields response messages.
|
||||
* The generator is guaranteed to end with either a 'result' or 'error' message.
|
||||
*
|
||||
* @example
|
||||
* ```typescript
|
||||
* const stream = protocol.requestStream(request, resultSchema, options);
|
||||
* for await (const message of stream) {
|
||||
* switch (message.type) {
|
||||
* case 'taskCreated':
|
||||
* console.log('Task created:', message.task.taskId);
|
||||
* break;
|
||||
* case 'taskStatus':
|
||||
* console.log('Task status:', message.task.status);
|
||||
* break;
|
||||
* case 'result':
|
||||
* console.log('Final result:', message.result);
|
||||
* break;
|
||||
* case 'error':
|
||||
* console.error('Error:', message.error);
|
||||
* break;
|
||||
* }
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* @experimental Use `client.experimental.tasks.requestStream()` to access this method.
|
||||
*/
|
||||
protected requestStream<T extends AnySchema>(request: SendRequestT, resultSchema: T, options?: RequestOptions): AsyncGenerator<ResponseMessage<SchemaOutput<T>>, void, void>;
|
||||
/**
|
||||
* Sends a request and waits for a response.
|
||||
* Sends a request and wait for a response.
|
||||
*
|
||||
* Do not use this method to emit notifications! Use notification() instead.
|
||||
*/
|
||||
request<T extends AnySchema>(request: SendRequestT, resultSchema: T, options?: RequestOptions): Promise<SchemaOutput<T>>;
|
||||
/**
|
||||
* Gets the current status of a task.
|
||||
*
|
||||
* @experimental Use `client.experimental.tasks.getTask()` to access this method.
|
||||
*/
|
||||
protected getTask(params: GetTaskRequest['params'], options?: RequestOptions): Promise<GetTaskResult>;
|
||||
/**
|
||||
* Retrieves the result of a completed task.
|
||||
*
|
||||
* @experimental Use `client.experimental.tasks.getTaskResult()` to access this method.
|
||||
*/
|
||||
protected getTaskResult<T extends AnySchema>(params: GetTaskPayloadRequest['params'], resultSchema: T, options?: RequestOptions): Promise<SchemaOutput<T>>;
|
||||
/**
|
||||
* Lists tasks, optionally starting from a pagination cursor.
|
||||
*
|
||||
* @experimental Use `client.experimental.tasks.listTasks()` to access this method.
|
||||
*/
|
||||
protected listTasks(params?: {
|
||||
cursor?: string;
|
||||
}, options?: RequestOptions): Promise<SchemaOutput<typeof ListTasksResultSchema>>;
|
||||
/**
|
||||
* Cancels a specific task.
|
||||
*
|
||||
* @experimental Use `client.experimental.tasks.cancelTask()` to access this method.
|
||||
*/
|
||||
protected cancelTask(params: {
|
||||
taskId: string;
|
||||
}, options?: RequestOptions): Promise<SchemaOutput<typeof CancelTaskResultSchema>>;
|
||||
request<T extends ZodType<object>>(request: SendRequestT, resultSchema: T, options?: RequestOptions): Promise<z.infer<T>>;
|
||||
/**
|
||||
* Emits a notification, which is a one-way message that does not expect a response.
|
||||
*/
|
||||
@@ -386,7 +201,9 @@ export declare abstract class Protocol<SendRequestT extends Request, SendNotific
|
||||
*
|
||||
* Note that this will replace any previous request handler for the same method.
|
||||
*/
|
||||
setRequestHandler<T extends AnyObjectSchema>(requestSchema: T, handler: (request: SchemaOutput<T>, extra: RequestHandlerExtra<SendRequestT, SendNotificationT>) => SendResultT | Promise<SendResultT>): void;
|
||||
setRequestHandler<T extends ZodObject<{
|
||||
method: ZodLiteral<string>;
|
||||
}>>(requestSchema: T, handler: (request: z.infer<T>, extra: RequestHandlerExtra<SendRequestT, SendNotificationT>) => SendResultT | Promise<SendResultT>): void;
|
||||
/**
|
||||
* Removes the request handler for the given method.
|
||||
*/
|
||||
@@ -400,44 +217,13 @@ export declare abstract class Protocol<SendRequestT extends Request, SendNotific
|
||||
*
|
||||
* Note that this will replace any previous notification handler for the same method.
|
||||
*/
|
||||
setNotificationHandler<T extends AnyObjectSchema>(notificationSchema: T, handler: (notification: SchemaOutput<T>) => void | Promise<void>): void;
|
||||
setNotificationHandler<T extends ZodObject<{
|
||||
method: ZodLiteral<string>;
|
||||
}>>(notificationSchema: T, handler: (notification: z.infer<T>) => void | Promise<void>): void;
|
||||
/**
|
||||
* Removes the notification handler for the given method.
|
||||
*/
|
||||
removeNotificationHandler(method: string): void;
|
||||
/**
|
||||
* Cleans up the progress handler associated with a task.
|
||||
* This should be called when a task reaches a terminal status.
|
||||
*/
|
||||
private _cleanupTaskProgressHandler;
|
||||
/**
|
||||
* Enqueues a task-related message for side-channel delivery via tasks/result.
|
||||
* @param taskId The task ID to associate the message with
|
||||
* @param message The message to enqueue
|
||||
* @param sessionId Optional session ID for binding the operation to a specific session
|
||||
* @throws Error if taskStore is not configured or if enqueue fails (e.g., queue overflow)
|
||||
*
|
||||
* Note: If enqueue fails, it's the TaskMessageQueue implementation's responsibility to handle
|
||||
* the error appropriately (e.g., by failing the task, logging, etc.). The Protocol layer
|
||||
* simply propagates the error.
|
||||
*/
|
||||
private _enqueueTaskMessage;
|
||||
/**
|
||||
* Clears the message queue for a task and rejects any pending request resolvers.
|
||||
* @param taskId The task ID whose queue should be cleared
|
||||
* @param sessionId Optional session ID for binding the operation to a specific session
|
||||
*/
|
||||
private _clearTaskQueue;
|
||||
/**
|
||||
* Waits for a task update (new messages or status change) with abort signal support.
|
||||
* Uses polling to check for updates at the task's configured poll interval.
|
||||
* @param taskId The task ID to wait for
|
||||
* @param signal Abort signal to cancel the wait
|
||||
* @returns Promise that resolves when an update occurs or rejects if aborted
|
||||
*/
|
||||
private _waitForTaskUpdate;
|
||||
private requestTaskStore;
|
||||
}
|
||||
export declare function mergeCapabilities(base: ServerCapabilities, additional: Partial<ServerCapabilities>): ServerCapabilities;
|
||||
export declare function mergeCapabilities(base: ClientCapabilities, additional: Partial<ClientCapabilities>): ClientCapabilities;
|
||||
export declare function mergeCapabilities<T extends ServerCapabilities | ClientCapabilities>(base: T, additional: T): T;
|
||||
//# sourceMappingURL=protocol.d.ts.map
|
||||
Reference in New Issue
Block a user