From ae3381e5bb64d2e6e932f4dc9087406c3a7edbba Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 16 Sep 2026 02:49:53 +0000 Subject: [PATCH 1/2] Update Copilot CLI to 1.0.85 - Updated the shared CLI release pin - Re-ran code generators - Formatted generated code --- dotnet/src/Generated/Rpc.cs | 4 + dotnet/src/Generated/SessionEvents.cs | 94 ++++++++++- go/rpc/zsession_encoding.go | 12 ++ go/rpc/zsession_events.go | 55 ++++++- go/zsession_events.go | 4 + .../PermissionAssentDetectedEvent.java | 43 ++++++ ...ermissionContextualAuthorizationEvent.java | 51 ++++++ ...rmissionMessageAuthorizationReadEvent.java | 6 +- .../copilot/generated/SessionEvent.java | 4 + nodejs/package.json | 2 +- nodejs/src/cliVersion.ts | 2 +- nodejs/src/generated/session-events.ts | 134 +++++++++++++++- python/copilot/generated/session_events.py | 90 ++++++++++- rust/src/generated/session_events.rs | 146 +++++++++++++++++- 14 files changed, 635 insertions(+), 12 deletions(-) create mode 100644 java/sdk/src/generated/java/com/github/copilot/generated/PermissionAssentDetectedEvent.java create mode 100644 java/sdk/src/generated/java/com/github/copilot/generated/PermissionContextualAuthorizationEvent.java diff --git a/dotnet/src/Generated/Rpc.cs b/dotnet/src/Generated/Rpc.cs index 87b3f521b3..81cd4e6da8 100644 --- a/dotnet/src/Generated/Rpc.cs +++ b/dotnet/src/Generated/Rpc.cs @@ -39557,11 +39557,15 @@ public static void RegisterClientGlobalApiHandlers(JsonRpc rpc, ClientGlobalApiH [JsonSerializable(typeof(GitHub.Copilot.OmittedBinaryType), TypeInfoPropertyName = "SessionEventsOmittedBinaryType")] [JsonSerializable(typeof(GitHub.Copilot.PendingMessagesModifiedData), TypeInfoPropertyName = "SessionEventsPendingMessagesModifiedData")] [JsonSerializable(typeof(GitHub.Copilot.PendingMessagesModifiedEvent), TypeInfoPropertyName = "SessionEventsPendingMessagesModifiedEvent")] +[JsonSerializable(typeof(GitHub.Copilot.PermissionAssentDetectedData), TypeInfoPropertyName = "SessionEventsPermissionAssentDetectedData")] +[JsonSerializable(typeof(GitHub.Copilot.PermissionAssentDetectedEvent), TypeInfoPropertyName = "SessionEventsPermissionAssentDetectedEvent")] [JsonSerializable(typeof(GitHub.Copilot.PermissionAssistedApproval), TypeInfoPropertyName = "SessionEventsPermissionAssistedApproval")] [JsonSerializable(typeof(GitHub.Copilot.PermissionCarriedForwardData), TypeInfoPropertyName = "SessionEventsPermissionCarriedForwardData")] [JsonSerializable(typeof(GitHub.Copilot.PermissionCarriedForwardEvent), TypeInfoPropertyName = "SessionEventsPermissionCarriedForwardEvent")] [JsonSerializable(typeof(GitHub.Copilot.PermissionCompletedData), TypeInfoPropertyName = "SessionEventsPermissionCompletedData")] [JsonSerializable(typeof(GitHub.Copilot.PermissionCompletedEvent), TypeInfoPropertyName = "SessionEventsPermissionCompletedEvent")] +[JsonSerializable(typeof(GitHub.Copilot.PermissionContextualAuthorizationData), TypeInfoPropertyName = "SessionEventsPermissionContextualAuthorizationData")] +[JsonSerializable(typeof(GitHub.Copilot.PermissionContextualAuthorizationEvent), TypeInfoPropertyName = "SessionEventsPermissionContextualAuthorizationEvent")] [JsonSerializable(typeof(GitHub.Copilot.PermissionDecisionSource), TypeInfoPropertyName = "SessionEventsPermissionDecisionSource")] [JsonSerializable(typeof(GitHub.Copilot.PermissionMessageAuthorizationData), TypeInfoPropertyName = "SessionEventsPermissionMessageAuthorizationData")] [JsonSerializable(typeof(GitHub.Copilot.PermissionMessageAuthorizationDegradedData), TypeInfoPropertyName = "SessionEventsPermissionMessageAuthorizationDegradedData")] diff --git a/dotnet/src/Generated/SessionEvents.cs b/dotnet/src/Generated/SessionEvents.cs index 27be572b84..f643dc002c 100644 --- a/dotnet/src/Generated/SessionEvents.cs +++ b/dotnet/src/Generated/SessionEvents.cs @@ -75,8 +75,10 @@ namespace GitHub.Copilot; [JsonDerivedType(typeof(ModelCallFinishedEvent), "model.call_finished")] [JsonDerivedType(typeof(ModelCallStartEvent), "model.call_start")] [JsonDerivedType(typeof(PendingMessagesModifiedEvent), "pending_messages.modified")] +[JsonDerivedType(typeof(PermissionAssentDetectedEvent), "permission.assentDetected")] [JsonDerivedType(typeof(PermissionCarriedForwardEvent), "permission.carriedForward")] [JsonDerivedType(typeof(PermissionCompletedEvent), "permission.completed")] +[JsonDerivedType(typeof(PermissionContextualAuthorizationEvent), "permission.contextualAuthorization")] [JsonDerivedType(typeof(PermissionMessageAuthorizationEvent), "permission.messageAuthorization")] [JsonDerivedType(typeof(PermissionMessageAuthorizationDegradedEvent), "permission.messageAuthorizationDegraded")] [JsonDerivedType(typeof(PermissionMessageAuthorizationReadEvent), "permission.messageAuthorizationRead")] @@ -1410,7 +1412,7 @@ public sealed partial class PermissionMessageAuthorizationEvent : SessionEvent public required PermissionMessageAuthorizationData Data { get; set; } } -/// Records that one human turn has been read by the blinded authorization proposer, whether or not it minted anything, so a resumed session does not re-run the extraction model on a turn the live session already read. Persisted purely to avoid wasted model calls across resume; it is never a correctness mechanism. +/// Records that one human turn has been read by the blinded authorization proposer, whether or not it minted anything, so a resumed session does not re-run the extraction model on a turn the live session already read. Also records whether that pass activates ongoing extraction; contextual-assent-only passes do not, so unrelated future messages remain outside extraction. /// Represents the permission.messageAuthorizationRead event. [Experimental(Diagnostics.Experimental)] public sealed partial class PermissionMessageAuthorizationReadEvent : SessionEvent @@ -1438,6 +1440,34 @@ public sealed partial class PermissionMessageAuthorizationDegradedEvent : Sessio public required PermissionMessageAuthorizationDegradedData Data { get; set; } } +/// Records that deterministic text recognition found likely assent in the human turn immediately following a root Autopilot permission request that was blocked because no interactive response was available. This event grants no authority; its model-facing projection only suggests retrying the unchanged operation. +/// Represents the permission.assentDetected event. +[Experimental(Diagnostics.Experimental)] +public sealed partial class PermissionAssentDetectedEvent : SessionEvent +{ + /// + [JsonIgnore] + public override string Type => "permission.assentDetected"; + + /// The permission.assentDetected event payload. + [JsonPropertyName("data")] + public required PermissionAssentDetectedData Data { get; set; } +} + +/// Freezes a blinded contextual authorization proposal whose verbatim human span was deterministically bound to the immediately preceding blocked permission request. The event carries no action fields; replay re-derives the exact action from the earlier permission request and mints a one-shot message grant only when the binding and span still verify. +/// Represents the permission.contextualAuthorization event. +[Experimental(Diagnostics.Experimental)] +public sealed partial class PermissionContextualAuthorizationEvent : SessionEvent +{ + /// + [JsonIgnore] + public override string Type => "permission.contextualAuthorization"; + + /// The permission.contextualAuthorization event payload. + [JsonPropertyName("data")] + public required PermissionContextualAuthorizationData Data { get; set; } +} + /// User input request notification with question and optional predefined choices. /// Represents the user_input.requested event. public sealed partial class UserInputRequestedEvent : SessionEvent @@ -5533,10 +5563,16 @@ public sealed partial class PermissionMessageAuthorizationData public JsonElement? World { get; set; } } -/// Records that one human turn has been read by the blinded authorization proposer, whether or not it minted anything, so a resumed session does not re-run the extraction model on a turn the live session already read. Persisted purely to avoid wasted model calls across resume; it is never a correctness mechanism. +/// Records that one human turn has been read by the blinded authorization proposer, whether or not it minted anything, so a resumed session does not re-run the extraction model on a turn the live session already read. Also records whether that pass activates ongoing extraction; contextual-assent-only passes do not, so unrelated future messages remain outside extraction. [Experimental(Diagnostics.Experimental)] public sealed partial class PermissionMessageAuthorizationReadData { + /// Whether this read activates ongoing message-backed extraction. False for a contextual-assent-only pass while auto-approval is off, so unrelated future messages remain outside extraction. + [Experimental(Diagnostics.Experimental)] + [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)] + [JsonPropertyName("activatesExtraction")] + public bool? ActivatesExtraction { get; set; } + /// The human turn that was read by the proposer. [Experimental(Diagnostics.Experimental)] [JsonPropertyName("turnIndex")] @@ -5553,6 +5589,56 @@ public sealed partial class PermissionMessageAuthorizationDegradedData public required long TurnIndex { get; set; } } +/// Records that deterministic text recognition found likely assent in the human turn immediately following a root Autopilot permission request that was blocked because no interactive response was available. This event grants no authority; its model-facing projection only suggests retrying the unchanged operation. +[Experimental(Diagnostics.Experimental)] +public sealed partial class PermissionAssentDetectedData +{ + /// Permission request the likely assent may refer to. The runtime derives this from the preceding durable blocker; the human message and extraction model do not choose it. + [Experimental(Diagnostics.Experimental)] + [JsonPropertyName("requestId")] + public required string RequestId { get; set; } + + /// Human turn whose text triggered the deterministic assent recognizer. + [Experimental(Diagnostics.Experimental)] + [JsonPropertyName("turnIndex")] + public required long TurnIndex { get; set; } +} + +/// Freezes a blinded contextual authorization proposal whose verbatim human span was deterministically bound to the immediately preceding blocked permission request. The event carries no action fields; replay re-derives the exact action from the earlier permission request and mints a one-shot message grant only when the binding and span still verify. +[Experimental(Diagnostics.Experimental)] +public sealed partial class PermissionContextualAuthorizationData +{ + /// Whether the contextual human span granted or denied authority. + [Experimental(Diagnostics.Experimental)] + [JsonPropertyName("polarity")] + public required PermissionMessageAuthorizationPolarity Polarity { get; set; } + + /// Deterministic identity of the contextual message grant. + [Experimental(Diagnostics.Experimental)] + [JsonPropertyName("recordId")] + public required string RecordId { get; set; } + + /// Original blocked permission request selected by deterministic event ordering, never by the extraction model. + [Experimental(Diagnostics.Experimental)] + [JsonPropertyName("requestId")] + public required string RequestId { get; set; } + + /// End byte offset of the contextual decision span within the turn. + [Experimental(Diagnostics.Experimental)] + [JsonPropertyName("spanEnd")] + public required long SpanEnd { get; set; } + + /// Start byte offset of the contextual decision span within the turn. + [Experimental(Diagnostics.Experimental)] + [JsonPropertyName("spanStart")] + public required long SpanStart { get; set; } + + /// Human turn containing the contextual decision. + [Experimental(Diagnostics.Experimental)] + [JsonPropertyName("turnIndex")] + public required long TurnIndex { get; set; } +} + /// User input request notification with question and optional predefined choices. public sealed partial class UserInputRequestedData { @@ -17383,11 +17469,15 @@ public override void Write(Utf8JsonWriter writer, ExtensionsLoadedExtensionStatu [JsonSerializable(typeof(OmittedBinaryResult))] [JsonSerializable(typeof(PendingMessagesModifiedData))] [JsonSerializable(typeof(PendingMessagesModifiedEvent))] +[JsonSerializable(typeof(PermissionAssentDetectedData))] +[JsonSerializable(typeof(PermissionAssentDetectedEvent))] [JsonSerializable(typeof(PermissionAssistedApproval))] [JsonSerializable(typeof(PermissionCarriedForwardData))] [JsonSerializable(typeof(PermissionCarriedForwardEvent))] [JsonSerializable(typeof(PermissionCompletedData))] [JsonSerializable(typeof(PermissionCompletedEvent))] +[JsonSerializable(typeof(PermissionContextualAuthorizationData))] +[JsonSerializable(typeof(PermissionContextualAuthorizationEvent))] [JsonSerializable(typeof(PermissionMessageAuthorizationData))] [JsonSerializable(typeof(PermissionMessageAuthorizationDegradedData))] [JsonSerializable(typeof(PermissionMessageAuthorizationDegradedEvent))] diff --git a/go/rpc/zsession_encoding.go b/go/rpc/zsession_encoding.go index 343c6c2f0f..847ed8869d 100644 --- a/go/rpc/zsession_encoding.go +++ b/go/rpc/zsession_encoding.go @@ -341,6 +341,12 @@ func (e *SessionEvent) UnmarshalJSON(data []byte) error { return err } e.Data = &d + case SessionEventTypePermissionAssentDetected: + var d PermissionAssentDetectedData + if err := json.Unmarshal(raw.Data, &d); err != nil { + return err + } + e.Data = &d case SessionEventTypePermissionCarriedForward: var d PermissionCarriedForwardData if err := json.Unmarshal(raw.Data, &d); err != nil { @@ -353,6 +359,12 @@ func (e *SessionEvent) UnmarshalJSON(data []byte) error { return err } e.Data = &d + case SessionEventTypePermissionContextualAuthorization: + var d PermissionContextualAuthorizationData + if err := json.Unmarshal(raw.Data, &d); err != nil { + return err + } + e.Data = &d case SessionEventTypePermissionMessageAuthorization: var d PermissionMessageAuthorizationData if err := json.Unmarshal(raw.Data, &d); err != nil { diff --git a/go/rpc/zsession_events.go b/go/rpc/zsession_events.go index 49d70bd70b..534eca386e 100644 --- a/go/rpc/zsession_events.go +++ b/go/rpc/zsession_events.go @@ -118,10 +118,16 @@ const ( SessionEventTypeModelCallFinished SessionEventType = "model.call_finished" SessionEventTypeModelCallStart SessionEventType = "model.call_start" SessionEventTypePendingMessagesModified SessionEventType = "pending_messages.modified" + // Experimental: SessionEventTypePermissionAssentDetected identifies an experimental event + // that may change or be removed. + SessionEventTypePermissionAssentDetected SessionEventType = "permission.assentDetected" // Experimental: SessionEventTypePermissionCarriedForward identifies an experimental event // that may change or be removed. SessionEventTypePermissionCarriedForward SessionEventType = "permission.carriedForward" SessionEventTypePermissionCompleted SessionEventType = "permission.completed" + // Experimental: SessionEventTypePermissionContextualAuthorization identifies an + // experimental event that may change or be removed. + SessionEventTypePermissionContextualAuthorization SessionEventType = "permission.contextualAuthorization" // Experimental: SessionEventTypePermissionMessageAuthorization identifies an experimental // event that may change or be removed. SessionEventTypePermissionMessageAuthorization SessionEventType = "permission.messageAuthorization" @@ -1363,6 +1369,34 @@ type ModelCallFinishedData struct { func (*ModelCallFinishedData) sessionEventData() {} func (*ModelCallFinishedData) Type() SessionEventType { return SessionEventTypeModelCallFinished } +// Freezes a blinded contextual authorization proposal whose verbatim human span was deterministically bound to the immediately preceding blocked permission request. The event carries no action fields; replay re-derives the exact action from the earlier permission request and mints a one-shot message grant only when the binding and span still verify. +// Experimental: PermissionContextualAuthorizationData is part of an experimental API and may change or be removed. +type PermissionContextualAuthorizationData struct { + // Whether the contextual human span granted or denied authority. + // Experimental: Polarity is part of an experimental API and may change or be removed. + Polarity PermissionMessageAuthorizationPolarity `json:"polarity"` + // Deterministic identity of the contextual message grant. + // Experimental: RecordID is part of an experimental API and may change or be removed. + RecordID string `json:"recordId"` + // Original blocked permission request selected by deterministic event ordering, never by the extraction model. + // Experimental: RequestID is part of an experimental API and may change or be removed. + RequestID string `json:"requestId"` + // End byte offset of the contextual decision span within the turn. + // Experimental: SpanEnd is part of an experimental API and may change or be removed. + SpanEnd int64 `json:"spanEnd"` + // Start byte offset of the contextual decision span within the turn. + // Experimental: SpanStart is part of an experimental API and may change or be removed. + SpanStart int64 `json:"spanStart"` + // Human turn containing the contextual decision. + // Experimental: TurnIndex is part of an experimental API and may change or be removed. + TurnIndex int64 `json:"turnIndex"` +} + +func (*PermissionContextualAuthorizationData) sessionEventData() {} +func (*PermissionContextualAuthorizationData) Type() SessionEventType { + return SessionEventTypePermissionContextualAuthorization +} + // Freezes one blinded, verbatim-verified authorization claim the runtime minted from a human user message, so a resumed session re-establishes the same grant deterministically instead of re-running the extraction model. This mints no authority on its own: it records what a blinded proposer pointed at and the trusted discriminator the runtime established, and deterministic establishment runs on replay. Persisted so recorded authority survives compaction and process resume. // Experimental: PermissionMessageAuthorizationData is part of an experimental API and may change or be removed. type PermissionMessageAuthorizationData struct { @@ -2257,6 +2291,22 @@ func (*SessionModeNoticeDeliveredData) Type() SessionEventType { return SessionEventTypeSessionModeNoticeDelivered } +// Records that deterministic text recognition found likely assent in the human turn immediately following a root Autopilot permission request that was blocked because no interactive response was available. This event grants no authority; its model-facing projection only suggests retrying the unchanged operation. +// Experimental: PermissionAssentDetectedData is part of an experimental API and may change or be removed. +type PermissionAssentDetectedData struct { + // Permission request the likely assent may refer to. The runtime derives this from the preceding durable blocker; the human message and extraction model do not choose it. + // Experimental: RequestID is part of an experimental API and may change or be removed. + RequestID string `json:"requestId"` + // Human turn whose text triggered the deterministic assent recognizer. + // Experimental: TurnIndex is part of an experimental API and may change or be removed. + TurnIndex int64 `json:"turnIndex"` +} + +func (*PermissionAssentDetectedData) sessionEventData() {} +func (*PermissionAssentDetectedData) Type() SessionEventType { + return SessionEventTypePermissionAssentDetected +} + // Records that message-backed authorization could not safely represent one human turn before compaction. The runtime may compact the original message after this marker is durable, but message-derived carry-forward and assisted auto-approval remain disabled for the rest of the session so subsequent commands continue through the ordinary permission prompt. // Experimental: PermissionMessageAuthorizationDegradedData is part of an experimental API and may change or be removed. type PermissionMessageAuthorizationDegradedData struct { @@ -2270,9 +2320,12 @@ func (*PermissionMessageAuthorizationDegradedData) Type() SessionEventType { return SessionEventTypePermissionMessageAuthorizationDegraded } -// Records that one human turn has been read by the blinded authorization proposer, whether or not it minted anything, so a resumed session does not re-run the extraction model on a turn the live session already read. Persisted purely to avoid wasted model calls across resume; it is never a correctness mechanism. +// Records that one human turn has been read by the blinded authorization proposer, whether or not it minted anything, so a resumed session does not re-run the extraction model on a turn the live session already read. Also records whether that pass activates ongoing extraction; contextual-assent-only passes do not, so unrelated future messages remain outside extraction. // Experimental: PermissionMessageAuthorizationReadData is part of an experimental API and may change or be removed. type PermissionMessageAuthorizationReadData struct { + // Whether this read activates ongoing message-backed extraction. False for a contextual-assent-only pass while auto-approval is off, so unrelated future messages remain outside extraction. + // Experimental: ActivatesExtraction is part of an experimental API and may change or be removed. + ActivatesExtraction *bool `json:"activatesExtraction,omitempty"` // The human turn that was read by the proposer. // Experimental: TurnIndex is part of an experimental API and may change or be removed. TurnIndex int64 `json:"turnIndex"` diff --git a/go/zsession_events.go b/go/zsession_events.go index 858f1d46af..c668f90601 100644 --- a/go/zsession_events.go +++ b/go/zsession_events.go @@ -192,10 +192,12 @@ type ( PermissionApproved = rpc.PermissionApproved PermissionApprovedForLocation = rpc.PermissionApprovedForLocation PermissionApprovedForSession = rpc.PermissionApprovedForSession + PermissionAssentDetectedData = rpc.PermissionAssentDetectedData PermissionAssistedApproval = rpc.PermissionAssistedApproval PermissionCancelled = rpc.PermissionCancelled PermissionCarriedForwardData = rpc.PermissionCarriedForwardData PermissionCompletedData = rpc.PermissionCompletedData + PermissionContextualAuthorizationData = rpc.PermissionContextualAuthorizationData PermissionDeniedByContentExclusionPolicy = rpc.PermissionDeniedByContentExclusionPolicy PermissionDeniedByPermissionRequestHook = rpc.PermissionDeniedByPermissionRequestHook PermissionDeniedByRules = rpc.PermissionDeniedByRules @@ -785,8 +787,10 @@ const ( SessionEventTypeModelCallFinished = rpc.SessionEventTypeModelCallFinished SessionEventTypeModelCallStart = rpc.SessionEventTypeModelCallStart SessionEventTypePendingMessagesModified = rpc.SessionEventTypePendingMessagesModified + SessionEventTypePermissionAssentDetected = rpc.SessionEventTypePermissionAssentDetected SessionEventTypePermissionCarriedForward = rpc.SessionEventTypePermissionCarriedForward SessionEventTypePermissionCompleted = rpc.SessionEventTypePermissionCompleted + SessionEventTypePermissionContextualAuthorization = rpc.SessionEventTypePermissionContextualAuthorization SessionEventTypePermissionMessageAuthorization = rpc.SessionEventTypePermissionMessageAuthorization SessionEventTypePermissionMessageAuthorizationDegraded = rpc.SessionEventTypePermissionMessageAuthorizationDegraded SessionEventTypePermissionMessageAuthorizationRead = rpc.SessionEventTypePermissionMessageAuthorizationRead diff --git a/java/sdk/src/generated/java/com/github/copilot/generated/PermissionAssentDetectedEvent.java b/java/sdk/src/generated/java/com/github/copilot/generated/PermissionAssentDetectedEvent.java new file mode 100644 index 0000000000..6e8d6aecb6 --- /dev/null +++ b/java/sdk/src/generated/java/com/github/copilot/generated/PermissionAssentDetectedEvent.java @@ -0,0 +1,43 @@ +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + *--------------------------------------------------------------------------------------------*/ + +// AUTO-GENERATED FILE - DO NOT EDIT +// Generated from: session-events.schema.json + +package com.github.copilot.generated; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import javax.annotation.processing.Generated; + +/** + * Session event "permission.assentDetected". Records that deterministic text recognition found likely assent in the human turn immediately following a root Autopilot permission request that was blocked because no interactive response was available. This event grants no authority; its model-facing projection only suggests retrying the unchanged operation. + * @since 1.0.0 + */ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@javax.annotation.processing.Generated("copilot-sdk-codegen") +public final class PermissionAssentDetectedEvent extends SessionEvent { + + @Override + public String getType() { return "permission.assentDetected"; } + + @JsonProperty("data") + private PermissionAssentDetectedEventData data; + + public PermissionAssentDetectedEventData getData() { return data; } + public void setData(PermissionAssentDetectedEventData data) { this.data = data; } + + /** Data payload for {@link PermissionAssentDetectedEvent}. */ + @JsonIgnoreProperties(ignoreUnknown = true) + @JsonInclude(JsonInclude.Include.NON_NULL) + public record PermissionAssentDetectedEventData( + /** Permission request the likely assent may refer to. The runtime derives this from the preceding durable blocker; the human message and extraction model do not choose it. */ + @JsonProperty("requestId") String requestId, + /** Human turn whose text triggered the deterministic assent recognizer. */ + @JsonProperty("turnIndex") Long turnIndex + ) { + } +} diff --git a/java/sdk/src/generated/java/com/github/copilot/generated/PermissionContextualAuthorizationEvent.java b/java/sdk/src/generated/java/com/github/copilot/generated/PermissionContextualAuthorizationEvent.java new file mode 100644 index 0000000000..2bee51662f --- /dev/null +++ b/java/sdk/src/generated/java/com/github/copilot/generated/PermissionContextualAuthorizationEvent.java @@ -0,0 +1,51 @@ +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + *--------------------------------------------------------------------------------------------*/ + +// AUTO-GENERATED FILE - DO NOT EDIT +// Generated from: session-events.schema.json + +package com.github.copilot.generated; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import javax.annotation.processing.Generated; + +/** + * Session event "permission.contextualAuthorization". Freezes a blinded contextual authorization proposal whose verbatim human span was deterministically bound to the immediately preceding blocked permission request. The event carries no action fields; replay re-derives the exact action from the earlier permission request and mints a one-shot message grant only when the binding and span still verify. + * @since 1.0.0 + */ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) +@javax.annotation.processing.Generated("copilot-sdk-codegen") +public final class PermissionContextualAuthorizationEvent extends SessionEvent { + + @Override + public String getType() { return "permission.contextualAuthorization"; } + + @JsonProperty("data") + private PermissionContextualAuthorizationEventData data; + + public PermissionContextualAuthorizationEventData getData() { return data; } + public void setData(PermissionContextualAuthorizationEventData data) { this.data = data; } + + /** Data payload for {@link PermissionContextualAuthorizationEvent}. */ + @JsonIgnoreProperties(ignoreUnknown = true) + @JsonInclude(JsonInclude.Include.NON_NULL) + public record PermissionContextualAuthorizationEventData( + /** Deterministic identity of the contextual message grant. */ + @JsonProperty("recordId") String recordId, + /** Original blocked permission request selected by deterministic event ordering, never by the extraction model. */ + @JsonProperty("requestId") String requestId, + /** Human turn containing the contextual decision. */ + @JsonProperty("turnIndex") Long turnIndex, + /** Whether the contextual human span granted or denied authority. */ + @JsonProperty("polarity") PermissionMessageAuthorizationPolarity polarity, + /** Start byte offset of the contextual decision span within the turn. */ + @JsonProperty("spanStart") Long spanStart, + /** End byte offset of the contextual decision span within the turn. */ + @JsonProperty("spanEnd") Long spanEnd + ) { + } +} diff --git a/java/sdk/src/generated/java/com/github/copilot/generated/PermissionMessageAuthorizationReadEvent.java b/java/sdk/src/generated/java/com/github/copilot/generated/PermissionMessageAuthorizationReadEvent.java index b05b7fc0bc..afa6ea4735 100644 --- a/java/sdk/src/generated/java/com/github/copilot/generated/PermissionMessageAuthorizationReadEvent.java +++ b/java/sdk/src/generated/java/com/github/copilot/generated/PermissionMessageAuthorizationReadEvent.java @@ -13,7 +13,7 @@ import javax.annotation.processing.Generated; /** - * Session event "permission.messageAuthorizationRead". Records that one human turn has been read by the blinded authorization proposer, whether or not it minted anything, so a resumed session does not re-run the extraction model on a turn the live session already read. Persisted purely to avoid wasted model calls across resume; it is never a correctness mechanism. + * Session event "permission.messageAuthorizationRead". Records that one human turn has been read by the blinded authorization proposer, whether or not it minted anything, so a resumed session does not re-run the extraction model on a turn the live session already read. Also records whether that pass activates ongoing extraction; contextual-assent-only passes do not, so unrelated future messages remain outside extraction. * @since 1.0.0 */ @JsonIgnoreProperties(ignoreUnknown = true) @@ -35,7 +35,9 @@ public final class PermissionMessageAuthorizationReadEvent extends SessionEvent @JsonInclude(JsonInclude.Include.NON_NULL) public record PermissionMessageAuthorizationReadEventData( /** The human turn that was read by the proposer. */ - @JsonProperty("turnIndex") Long turnIndex + @JsonProperty("turnIndex") Long turnIndex, + /** Whether this read activates ongoing message-backed extraction. False for a contextual-assent-only pass while auto-approval is off, so unrelated future messages remain outside extraction. */ + @JsonProperty("activatesExtraction") Boolean activatesExtraction ) { } } diff --git a/java/sdk/src/generated/java/com/github/copilot/generated/SessionEvent.java b/java/sdk/src/generated/java/com/github/copilot/generated/SessionEvent.java index 6d2d86b1e4..280b640138 100644 --- a/java/sdk/src/generated/java/com/github/copilot/generated/SessionEvent.java +++ b/java/sdk/src/generated/java/com/github/copilot/generated/SessionEvent.java @@ -118,6 +118,8 @@ @JsonSubTypes.Type(value = PermissionMessageAuthorizationEvent.class, name = "permission.messageAuthorization"), @JsonSubTypes.Type(value = PermissionMessageAuthorizationReadEvent.class, name = "permission.messageAuthorizationRead"), @JsonSubTypes.Type(value = PermissionMessageAuthorizationDegradedEvent.class, name = "permission.messageAuthorizationDegraded"), + @JsonSubTypes.Type(value = PermissionAssentDetectedEvent.class, name = "permission.assentDetected"), + @JsonSubTypes.Type(value = PermissionContextualAuthorizationEvent.class, name = "permission.contextualAuthorization"), @JsonSubTypes.Type(value = UserInputRequestedEvent.class, name = "user_input.requested"), @JsonSubTypes.Type(value = UserInputCompletedEvent.class, name = "user_input.completed"), @JsonSubTypes.Type(value = ElicitationRequestedEvent.class, name = "elicitation.requested"), @@ -265,6 +267,8 @@ public abstract sealed class SessionEvent permits PermissionMessageAuthorizationEvent, PermissionMessageAuthorizationReadEvent, PermissionMessageAuthorizationDegradedEvent, + PermissionAssentDetectedEvent, + PermissionContextualAuthorizationEvent, UserInputRequestedEvent, UserInputCompletedEvent, ElicitationRequestedEvent, diff --git a/nodejs/package.json b/nodejs/package.json index 162425a176..043751ff14 100644 --- a/nodejs/package.json +++ b/nodejs/package.json @@ -5,7 +5,7 @@ "url": "https://github.com/github/copilot-sdk.git" }, "version": "0.0.0-dev", - "copilotCliVersion": "1.0.84-8", + "copilotCliVersion": "1.0.85", "description": "TypeScript SDK for programmatic control of GitHub Copilot CLI via JSON-RPC", "main": "./dist/cjs/index.js", "types": "./dist/index.d.ts", diff --git a/nodejs/src/cliVersion.ts b/nodejs/src/cliVersion.ts index accc03512f..bdaffb487f 100644 --- a/nodejs/src/cliVersion.ts +++ b/nodejs/src/cliVersion.ts @@ -1,3 +1,3 @@ -export const COPILOT_CLI_VERSION = "1.0.84-8"; +export const COPILOT_CLI_VERSION = "1.0.85"; export const COPILOT_CLI_USE_NPM_PACKAGE = false; diff --git a/nodejs/src/generated/session-events.ts b/nodejs/src/generated/session-events.ts index 08bf03b5d7..acaf485146 100644 --- a/nodejs/src/generated/session-events.ts +++ b/nodejs/src/generated/session-events.ts @@ -95,6 +95,8 @@ export type SessionEvent = | PermissionMessageAuthorizationEvent | PermissionMessageAuthorizationReadEvent | PermissionMessageAuthorizationDegradedEvent + | PermissionAssentDetectedEvent + | PermissionContextualAuthorizationEvent | UserInputRequestedEvent | UserInputCompletedEvent | ElicitationRequestedEvent @@ -9633,7 +9635,7 @@ export interface PermissionMessageAuthorizationData { world?: JsonValue; } /** - * Session event "permission.messageAuthorizationRead". Records that one human turn has been read by the blinded authorization proposer, whether or not it minted anything, so a resumed session does not re-run the extraction model on a turn the live session already read. Persisted purely to avoid wasted model calls across resume; it is never a correctness mechanism. + * Session event "permission.messageAuthorizationRead". Records that one human turn has been read by the blinded authorization proposer, whether or not it minted anything, so a resumed session does not re-run the extraction model on a turn the live session already read. Also records whether that pass activates ongoing extraction; contextual-assent-only passes do not, so unrelated future messages remain outside extraction. */ /** @experimental */ export interface PermissionMessageAuthorizationReadEvent { @@ -9664,10 +9666,16 @@ export interface PermissionMessageAuthorizationReadEvent { type: "permission.messageAuthorizationRead"; } /** - * Records that one human turn has been read by the blinded authorization proposer, whether or not it minted anything, so a resumed session does not re-run the extraction model on a turn the live session already read. Persisted purely to avoid wasted model calls across resume; it is never a correctness mechanism. + * Records that one human turn has been read by the blinded authorization proposer, whether or not it minted anything, so a resumed session does not re-run the extraction model on a turn the live session already read. Also records whether that pass activates ongoing extraction; contextual-assent-only passes do not, so unrelated future messages remain outside extraction. */ /** @experimental */ export interface PermissionMessageAuthorizationReadData { + /** + * Whether this read activates ongoing message-backed extraction. False for a contextual-assent-only pass while auto-approval is off, so unrelated future messages remain outside extraction. + * + * @experimental + */ + activatesExtraction?: boolean; /** * The human turn that was read by the proposer. * @@ -9718,6 +9726,128 @@ export interface PermissionMessageAuthorizationDegradedData { */ turnIndex: number; } +/** + * Session event "permission.assentDetected". Records that deterministic text recognition found likely assent in the human turn immediately following a root Autopilot permission request that was blocked because no interactive response was available. This event grants no authority; its model-facing projection only suggests retrying the unchanged operation. + */ +/** @experimental */ +export interface PermissionAssentDetectedEvent { + /** + * Sub-agent instance identifier. Absent for events from the root/main agent and session-level events. + */ + agentId?: string; + data: PermissionAssentDetectedData; + /** + * When true, the event is transient and not persisted to the session event log on disk + */ + ephemeral?: boolean; + /** + * Unique event identifier (UUID v4), generated when the event is emitted + */ + id: string; + /** + * ID of the chronologically preceding event in the session, forming a linked chain. Null for the first event. + */ + parentId: string | null; + /** + * ISO 8601 timestamp when the event was created + */ + timestamp: string; + /** + * Type discriminator. Always "permission.assentDetected". + */ + type: "permission.assentDetected"; +} +/** + * Records that deterministic text recognition found likely assent in the human turn immediately following a root Autopilot permission request that was blocked because no interactive response was available. This event grants no authority; its model-facing projection only suggests retrying the unchanged operation. + */ +/** @experimental */ +export interface PermissionAssentDetectedData { + /** + * Permission request the likely assent may refer to. The runtime derives this from the preceding durable blocker; the human message and extraction model do not choose it. + * + * @experimental + */ + requestId: string; + /** + * Human turn whose text triggered the deterministic assent recognizer. + * + * @experimental + */ + turnIndex: number; +} +/** + * Session event "permission.contextualAuthorization". Freezes a blinded contextual authorization proposal whose verbatim human span was deterministically bound to the immediately preceding blocked permission request. The event carries no action fields; replay re-derives the exact action from the earlier permission request and mints a one-shot message grant only when the binding and span still verify. + */ +/** @experimental */ +export interface PermissionContextualAuthorizationEvent { + /** + * Sub-agent instance identifier. Absent for events from the root/main agent and session-level events. + */ + agentId?: string; + data: PermissionContextualAuthorizationData; + /** + * When true, the event is transient and not persisted to the session event log on disk + */ + ephemeral?: boolean; + /** + * Unique event identifier (UUID v4), generated when the event is emitted + */ + id: string; + /** + * ID of the chronologically preceding event in the session, forming a linked chain. Null for the first event. + */ + parentId: string | null; + /** + * ISO 8601 timestamp when the event was created + */ + timestamp: string; + /** + * Type discriminator. Always "permission.contextualAuthorization". + */ + type: "permission.contextualAuthorization"; +} +/** + * Freezes a blinded contextual authorization proposal whose verbatim human span was deterministically bound to the immediately preceding blocked permission request. The event carries no action fields; replay re-derives the exact action from the earlier permission request and mints a one-shot message grant only when the binding and span still verify. + */ +/** @experimental */ +export interface PermissionContextualAuthorizationData { + /** + * Whether the contextual human span granted or denied authority. + * + * @experimental + */ + polarity: PermissionMessageAuthorizationPolarity; + /** + * Deterministic identity of the contextual message grant. + * + * @experimental + */ + recordId: string; + /** + * Original blocked permission request selected by deterministic event ordering, never by the extraction model. + * + * @experimental + */ + requestId: string; + /** + * End byte offset of the contextual decision span within the turn. + * + * @experimental + */ + spanEnd: number; + /** + * Start byte offset of the contextual decision span within the turn. + * + * @experimental + */ + spanStart: number; + /** + * Human turn containing the contextual decision. + * + * @experimental + */ + turnIndex: number; +} /** * Session event "user_input.requested". User input request notification with question and optional predefined choices */ diff --git a/python/copilot/generated/session_events.py b/python/copilot/generated/session_events.py index f47d7c9420..f9cb382aab 100644 --- a/python/copilot/generated/session_events.py +++ b/python/copilot/generated/session_events.py @@ -235,6 +235,10 @@ class SessionEventType(Enum): PERMISSION_MESSAGE_AUTHORIZATION_READ = "permission.messageAuthorizationRead" # Experimental: this event is part of an experimental API and may change or be removed. PERMISSION_MESSAGE_AUTHORIZATION_DEGRADED = "permission.messageAuthorizationDegraded" + # Experimental: this event is part of an experimental API and may change or be removed. + PERMISSION_ASSENT_DETECTED = "permission.assentDetected" + # Experimental: this event is part of an experimental API and may change or be removed. + PERMISSION_CONTEXTUAL_AUTHORIZATION = "permission.contextualAuthorization" USER_INPUT_REQUESTED = "user_input.requested" USER_INPUT_COMPLETED = "user_input.completed" ELICITATION_REQUESTED = "elicitation.requested" @@ -1462,6 +1466,32 @@ def to_dict(self) -> dict: return result +# Experimental: this type is part of an experimental API and may change or be removed. +@dataclass +class PermissionAssentDetectedData: + "Records that deterministic text recognition found likely assent in the human turn immediately following a root Autopilot permission request that was blocked because no interactive response was available. This event grants no authority; its model-facing projection only suggests retrying the unchanged operation." + # Experimental: this field is part of an experimental API and may change or be removed. + request_id: str + # Experimental: this field is part of an experimental API and may change or be removed. + turn_index: int + + @staticmethod + def from_dict(obj: Any) -> "PermissionAssentDetectedData": + assert isinstance(obj, dict) + request_id = from_str(obj.get("requestId")) + turn_index = from_int(obj.get("turnIndex")) + return PermissionAssentDetectedData( + request_id=request_id, + turn_index=turn_index, + ) + + def to_dict(self) -> dict: + result: dict = {} + result["requestId"] = from_str(self.request_id) + result["turnIndex"] = to_int(self.turn_index) + return result + + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class PermissionAssistedApproval: @@ -1533,6 +1563,52 @@ def to_dict(self) -> dict: return result +# Experimental: this type is part of an experimental API and may change or be removed. +@dataclass +class PermissionContextualAuthorizationData: + "Freezes a blinded contextual authorization proposal whose verbatim human span was deterministically bound to the immediately preceding blocked permission request. The event carries no action fields; replay re-derives the exact action from the earlier permission request and mints a one-shot message grant only when the binding and span still verify." + # Experimental: this field is part of an experimental API and may change or be removed. + polarity: PermissionMessageAuthorizationPolarity + # Experimental: this field is part of an experimental API and may change or be removed. + record_id: str + # Experimental: this field is part of an experimental API and may change or be removed. + request_id: str + # Experimental: this field is part of an experimental API and may change or be removed. + span_end: int + # Experimental: this field is part of an experimental API and may change or be removed. + span_start: int + # Experimental: this field is part of an experimental API and may change or be removed. + turn_index: int + + @staticmethod + def from_dict(obj: Any) -> "PermissionContextualAuthorizationData": + assert isinstance(obj, dict) + polarity = parse_enum(PermissionMessageAuthorizationPolarity, obj.get("polarity")) + record_id = from_str(obj.get("recordId")) + request_id = from_str(obj.get("requestId")) + span_end = from_int(obj.get("spanEnd")) + span_start = from_int(obj.get("spanStart")) + turn_index = from_int(obj.get("turnIndex")) + return PermissionContextualAuthorizationData( + polarity=polarity, + record_id=record_id, + request_id=request_id, + span_end=span_end, + span_start=span_start, + turn_index=turn_index, + ) + + def to_dict(self) -> dict: + result: dict = {} + result["polarity"] = to_enum(PermissionMessageAuthorizationPolarity, self.polarity) + result["recordId"] = from_str(self.record_id) + result["requestId"] = from_str(self.request_id) + result["spanEnd"] = to_int(self.span_end) + result["spanStart"] = to_int(self.span_start) + result["turnIndex"] = to_int(self.turn_index) + return result + + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class PermissionMessageAuthorizationData: @@ -1621,21 +1697,27 @@ def to_dict(self) -> dict: # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class PermissionMessageAuthorizationReadData: - "Records that one human turn has been read by the blinded authorization proposer, whether or not it minted anything, so a resumed session does not re-run the extraction model on a turn the live session already read. Persisted purely to avoid wasted model calls across resume; it is never a correctness mechanism." + "Records that one human turn has been read by the blinded authorization proposer, whether or not it minted anything, so a resumed session does not re-run the extraction model on a turn the live session already read. Also records whether that pass activates ongoing extraction; contextual-assent-only passes do not, so unrelated future messages remain outside extraction." # Experimental: this field is part of an experimental API and may change or be removed. turn_index: int + # Experimental: this field is part of an experimental API and may change or be removed. + activates_extraction: bool | None = None @staticmethod def from_dict(obj: Any) -> "PermissionMessageAuthorizationReadData": assert isinstance(obj, dict) turn_index = from_int(obj.get("turnIndex")) + activates_extraction = from_union([from_none, from_bool], obj.get("activatesExtraction")) return PermissionMessageAuthorizationReadData( turn_index=turn_index, + activates_extraction=activates_extraction, ) def to_dict(self) -> dict: result: dict = {} result["turnIndex"] = to_int(self.turn_index) + if self.activates_extraction is not None: + result["activatesExtraction"] = from_union([from_none, from_bool], self.activates_extraction) return result @@ -13381,7 +13463,7 @@ class WorkspaceFileChangedOperation(Enum): UPDATE = "update" -SessionEventData = SessionStartData | SessionResumeData | SessionRemoteSteerableChangedData | SessionErrorData | SessionIdleData | SessionTitleChangedData | SessionScheduleCreatedData | SessionScheduleCancelledData | SessionScheduleRearmedData | SessionAutopilotObjectiveChangedData | SessionInfoData | SessionWarningData | SessionModelChangeData | SessionAutoTierRecommendationData | SessionAutoTierSwitchFailedData | SessionModeChangedData | SessionModeNoticeDeliveredData | SessionSessionLimitsChangedData | SessionPermissionsChangedData | SessionPlanChangedData | SessionTodosChangedData | SessionWorkspaceFileChangedData | SessionHandoffData | SessionTruncationData | SessionSnapshotRewindData | SessionShutdownData | SessionUsageCheckpointData | SessionContextChangedData | SessionUsageInfoData | SessionContextClearedData | SessionCompactionStartData | SessionCompactionCompleteData | SessionTaskCompleteData | SessionCompletionReceiptData | SessionFusionRouteStartedData | SessionFusionRouteFailedData | SessionFusionResolvedData | SessionFusionCompletedData | UserMessageData | PendingMessagesModifiedData | AssistantTurnStartData | AssistantTurnRetryData | AgentInterruptedData | AssistantIntentData | AssistantFusionPhaseStartedData | AssistantFusionPhaseActivityData | AssistantFusionPhaseCompletedData | AssistantFusionPhaseFailedData | AssistantServerToolProgressData | AssistantReasoningData | AssistantReasoningDeltaData | AssistantToolCallDeltaData | AssistantStreamingDeltaData | AssistantMessageData | AssistantMessageStartData | AssistantMessageDeltaData | AssistantTurnEndData | AssistantIdleData | AssistantUsageData | PromptCacheBreakData | ModelCallFailureData | ModelCallFinishedData | ModelCallStartData | AbortData | ToolUserRequestedData | ToolExecutionStartData | ToolExecutionPartialResultData | ToolExecutionProgressData | ToolExecutionCompleteData | ToolSearchActivatedData | SkillInvokedData | SkillInvokedRefData | SkillContextDeliveredData | SkillContextDeliveredRefData | SandboxDecisionData | SubagentStartedData | SubagentConfiguredData | SubagentCompletedData | SubagentFailedData | SubagentSelectedData | SubagentDeselectedData | HookStartData | HookEndData | HookProgressData | SessionBinaryAssetData | SystemMessageData | SystemNotificationData | PermissionRequestedData | PermissionCompletedData | PermissionCarriedForwardData | PermissionMessageAuthorizationData | PermissionMessageAuthorizationReadData | PermissionMessageAuthorizationDegradedData | UserInputRequestedData | UserInputCompletedData | ElicitationRequestedData | ElicitationCompletedData | SamplingRequestedData | SamplingCompletedData | McpOauthRequiredData | McpOauthCompletedData | McpHeadersRefreshRequiredData | McpHeadersRefreshCompletedData | SessionCustomNotificationData | UiEphemeralQueryData | ExternalToolRequestedData | ExternalToolCompletedData | CommandQueuedData | CommandExecuteData | CommandCompletedData | AutoModeSwitchRequestedData | AutoModeSwitchCompletedData | SessionLimitsExhaustedRequestedData | SessionLimitsExhaustedCompletedData | SessionAutoModeResolvedData | SessionManagedSettingsResolvedData | SessionManagedSettingsEnforcedData | CommandsChangedData | CapabilitiesChangedData | ExitPlanModeRequestedData | ExitPlanModeCompletedData | SessionToolsUpdatedData | SessionBackgroundTasksChangedData | FactoryRunUpdatedData | FactoryRunStartedData | FactoryRunSettledData | SessionSkillsLoadedData | SessionCustomAgentsUpdatedData | SessionMcpServersLoadedData | SessionMcpServerStatusChangedData | SessionMcpServerRemovedData | SessionMcpServerNeedsReconnectData | McpToolsListChangedData | McpResourcesListChangedData | McpPromptsListChangedData | SessionExtensionsLoadedData | SessionCanvasOpenedData | SessionCanvasRegistryChangedData | SessionCanvasClosedData | SessionCanvasUnavailableData | SessionCanvasRecordedData | SessionCanvasRemovedData | SessionExtensionsAttachmentsPushedData | McpAppToolCallCompleteData | RawSessionEventData | Data +SessionEventData = SessionStartData | SessionResumeData | SessionRemoteSteerableChangedData | SessionErrorData | SessionIdleData | SessionTitleChangedData | SessionScheduleCreatedData | SessionScheduleCancelledData | SessionScheduleRearmedData | SessionAutopilotObjectiveChangedData | SessionInfoData | SessionWarningData | SessionModelChangeData | SessionAutoTierRecommendationData | SessionAutoTierSwitchFailedData | SessionModeChangedData | SessionModeNoticeDeliveredData | SessionSessionLimitsChangedData | SessionPermissionsChangedData | SessionPlanChangedData | SessionTodosChangedData | SessionWorkspaceFileChangedData | SessionHandoffData | SessionTruncationData | SessionSnapshotRewindData | SessionShutdownData | SessionUsageCheckpointData | SessionContextChangedData | SessionUsageInfoData | SessionContextClearedData | SessionCompactionStartData | SessionCompactionCompleteData | SessionTaskCompleteData | SessionCompletionReceiptData | SessionFusionRouteStartedData | SessionFusionRouteFailedData | SessionFusionResolvedData | SessionFusionCompletedData | UserMessageData | PendingMessagesModifiedData | AssistantTurnStartData | AssistantTurnRetryData | AgentInterruptedData | AssistantIntentData | AssistantFusionPhaseStartedData | AssistantFusionPhaseActivityData | AssistantFusionPhaseCompletedData | AssistantFusionPhaseFailedData | AssistantServerToolProgressData | AssistantReasoningData | AssistantReasoningDeltaData | AssistantToolCallDeltaData | AssistantStreamingDeltaData | AssistantMessageData | AssistantMessageStartData | AssistantMessageDeltaData | AssistantTurnEndData | AssistantIdleData | AssistantUsageData | PromptCacheBreakData | ModelCallFailureData | ModelCallFinishedData | ModelCallStartData | AbortData | ToolUserRequestedData | ToolExecutionStartData | ToolExecutionPartialResultData | ToolExecutionProgressData | ToolExecutionCompleteData | ToolSearchActivatedData | SkillInvokedData | SkillInvokedRefData | SkillContextDeliveredData | SkillContextDeliveredRefData | SandboxDecisionData | SubagentStartedData | SubagentConfiguredData | SubagentCompletedData | SubagentFailedData | SubagentSelectedData | SubagentDeselectedData | HookStartData | HookEndData | HookProgressData | SessionBinaryAssetData | SystemMessageData | SystemNotificationData | PermissionRequestedData | PermissionCompletedData | PermissionCarriedForwardData | PermissionMessageAuthorizationData | PermissionMessageAuthorizationReadData | PermissionMessageAuthorizationDegradedData | PermissionAssentDetectedData | PermissionContextualAuthorizationData | UserInputRequestedData | UserInputCompletedData | ElicitationRequestedData | ElicitationCompletedData | SamplingRequestedData | SamplingCompletedData | McpOauthRequiredData | McpOauthCompletedData | McpHeadersRefreshRequiredData | McpHeadersRefreshCompletedData | SessionCustomNotificationData | UiEphemeralQueryData | ExternalToolRequestedData | ExternalToolCompletedData | CommandQueuedData | CommandExecuteData | CommandCompletedData | AutoModeSwitchRequestedData | AutoModeSwitchCompletedData | SessionLimitsExhaustedRequestedData | SessionLimitsExhaustedCompletedData | SessionAutoModeResolvedData | SessionManagedSettingsResolvedData | SessionManagedSettingsEnforcedData | CommandsChangedData | CapabilitiesChangedData | ExitPlanModeRequestedData | ExitPlanModeCompletedData | SessionToolsUpdatedData | SessionBackgroundTasksChangedData | FactoryRunUpdatedData | FactoryRunStartedData | FactoryRunSettledData | SessionSkillsLoadedData | SessionCustomAgentsUpdatedData | SessionMcpServersLoadedData | SessionMcpServerStatusChangedData | SessionMcpServerRemovedData | SessionMcpServerNeedsReconnectData | McpToolsListChangedData | McpResourcesListChangedData | McpPromptsListChangedData | SessionExtensionsLoadedData | SessionCanvasOpenedData | SessionCanvasRegistryChangedData | SessionCanvasClosedData | SessionCanvasUnavailableData | SessionCanvasRecordedData | SessionCanvasRemovedData | SessionExtensionsAttachmentsPushedData | McpAppToolCallCompleteData | RawSessionEventData | Data @dataclass @@ -13500,6 +13582,8 @@ def from_dict(obj: Any) -> "SessionEvent": case SessionEventType.PERMISSION_MESSAGE_AUTHORIZATION: data = PermissionMessageAuthorizationData.from_dict(data_obj) case SessionEventType.PERMISSION_MESSAGE_AUTHORIZATION_READ: data = PermissionMessageAuthorizationReadData.from_dict(data_obj) case SessionEventType.PERMISSION_MESSAGE_AUTHORIZATION_DEGRADED: data = PermissionMessageAuthorizationDegradedData.from_dict(data_obj) + case SessionEventType.PERMISSION_ASSENT_DETECTED: data = PermissionAssentDetectedData.from_dict(data_obj) + case SessionEventType.PERMISSION_CONTEXTUAL_AUTHORIZATION: data = PermissionContextualAuthorizationData.from_dict(data_obj) case SessionEventType.USER_INPUT_REQUESTED: data = UserInputRequestedData.from_dict(data_obj) case SessionEventType.USER_INPUT_COMPLETED: data = UserInputCompletedData.from_dict(data_obj) case SessionEventType.ELICITATION_REQUESTED: data = ElicitationRequestedData.from_dict(data_obj) @@ -13769,10 +13853,12 @@ def session_event_to_dict(x: SessionEvent) -> Any: "PermissionApproved", "PermissionApprovedForLocation", "PermissionApprovedForSession", + "PermissionAssentDetectedData", "PermissionAssistedApproval", "PermissionCancelled", "PermissionCarriedForwardData", "PermissionCompletedData", + "PermissionContextualAuthorizationData", "PermissionDecisionSource", "PermissionDeniedByContentExclusionPolicy", "PermissionDeniedByPermissionRequestHook", diff --git a/rust/src/generated/session_events.rs b/rust/src/generated/session_events.rs index d9ebdfff47..f34ee19e7b 100644 --- a/rust/src/generated/session_events.rs +++ b/rust/src/generated/session_events.rs @@ -330,6 +330,24 @@ pub enum SessionEventType { /// #[serde(rename = "permission.messageAuthorizationDegraded")] PermissionMessageAuthorizationDegraded, + /// + ///
+ /// + /// **Experimental.** This type is part of an experimental wire-protocol surface + /// and may change or be removed in future SDK or CLI releases. + /// + ///
+ #[serde(rename = "permission.assentDetected")] + PermissionAssentDetected, + /// + ///
+ /// + /// **Experimental.** This type is part of an experimental wire-protocol surface + /// and may change or be removed in future SDK or CLI releases. + /// + ///
+ #[serde(rename = "permission.contextualAuthorization")] + PermissionContextualAuthorization, #[serde(rename = "user_input.requested")] UserInputRequested, #[serde(rename = "user_input.completed")] @@ -826,6 +844,24 @@ pub enum SessionEventData { /// #[serde(rename = "permission.messageAuthorizationDegraded")] PermissionMessageAuthorizationDegraded(PermissionMessageAuthorizationDegradedData), + /// + ///
+ /// + /// **Experimental.** This type is part of an experimental wire-protocol surface + /// and may change or be removed in future SDK or CLI releases. + /// + ///
+ #[serde(rename = "permission.assentDetected")] + PermissionAssentDetected(PermissionAssentDetectedData), + /// + ///
+ /// + /// **Experimental.** This type is part of an experimental wire-protocol surface + /// and may change or be removed in future SDK or CLI releases. + /// + ///
+ #[serde(rename = "permission.contextualAuthorization")] + PermissionContextualAuthorization(PermissionContextualAuthorizationData), #[serde(rename = "user_input.requested")] UserInputRequested(UserInputRequestedData), #[serde(rename = "user_input.completed")] @@ -5991,7 +6027,7 @@ pub struct PermissionMessageAuthorizationData { pub world: Option, } -/// Session event "permission.messageAuthorizationRead". Records that one human turn has been read by the blinded authorization proposer, whether or not it minted anything, so a resumed session does not re-run the extraction model on a turn the live session already read. Persisted purely to avoid wasted model calls across resume; it is never a correctness mechanism. +/// Session event "permission.messageAuthorizationRead". Records that one human turn has been read by the blinded authorization proposer, whether or not it minted anything, so a resumed session does not re-run the extraction model on a turn the live session already read. Also records whether that pass activates ongoing extraction; contextual-assent-only passes do not, so unrelated future messages remain outside extraction. /// ///
/// @@ -6002,6 +6038,16 @@ pub struct PermissionMessageAuthorizationData { #[derive(Debug, Clone, Default, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct PermissionMessageAuthorizationReadData { + /// Whether this read activates ongoing message-backed extraction. False for a contextual-assent-only pass while auto-approval is off, so unrelated future messages remain outside extraction. + /// + ///
+ /// + /// **Experimental.** This type is part of an experimental wire-protocol surface + /// and may change or be removed in future SDK or CLI releases. + /// + ///
+ #[serde(skip_serializing_if = "Option::is_none")] + pub activates_extraction: Option, /// The human turn that was read by the proposer. /// ///
@@ -6035,6 +6081,104 @@ pub struct PermissionMessageAuthorizationDegradedData { pub turn_index: i64, } +/// Session event "permission.assentDetected". Records that deterministic text recognition found likely assent in the human turn immediately following a root Autopilot permission request that was blocked because no interactive response was available. This event grants no authority; its model-facing projection only suggests retrying the unchanged operation. +/// +///
+/// +/// **Experimental.** This type is part of an experimental wire-protocol surface +/// and may change or be removed in future SDK or CLI releases. +/// +///
+#[derive(Debug, Clone, Default, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct PermissionAssentDetectedData { + /// Permission request the likely assent may refer to. The runtime derives this from the preceding durable blocker; the human message and extraction model do not choose it. + /// + ///
+ /// + /// **Experimental.** This type is part of an experimental wire-protocol surface + /// and may change or be removed in future SDK or CLI releases. + /// + ///
+ pub request_id: RequestId, + /// Human turn whose text triggered the deterministic assent recognizer. + /// + ///
+ /// + /// **Experimental.** This type is part of an experimental wire-protocol surface + /// and may change or be removed in future SDK or CLI releases. + /// + ///
+ pub turn_index: i64, +} + +/// Session event "permission.contextualAuthorization". Freezes a blinded contextual authorization proposal whose verbatim human span was deterministically bound to the immediately preceding blocked permission request. The event carries no action fields; replay re-derives the exact action from the earlier permission request and mints a one-shot message grant only when the binding and span still verify. +/// +///
+/// +/// **Experimental.** This type is part of an experimental wire-protocol surface +/// and may change or be removed in future SDK or CLI releases. +/// +///
+#[derive(Debug, Clone, Default, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct PermissionContextualAuthorizationData { + /// Whether the contextual human span granted or denied authority. + /// + ///
+ /// + /// **Experimental.** This type is part of an experimental wire-protocol surface + /// and may change or be removed in future SDK or CLI releases. + /// + ///
+ pub polarity: PermissionMessageAuthorizationPolarity, + /// Deterministic identity of the contextual message grant. + /// + ///
+ /// + /// **Experimental.** This type is part of an experimental wire-protocol surface + /// and may change or be removed in future SDK or CLI releases. + /// + ///
+ pub record_id: String, + /// Original blocked permission request selected by deterministic event ordering, never by the extraction model. + /// + ///
+ /// + /// **Experimental.** This type is part of an experimental wire-protocol surface + /// and may change or be removed in future SDK or CLI releases. + /// + ///
+ pub request_id: RequestId, + /// End byte offset of the contextual decision span within the turn. + /// + ///
+ /// + /// **Experimental.** This type is part of an experimental wire-protocol surface + /// and may change or be removed in future SDK or CLI releases. + /// + ///
+ pub span_end: i64, + /// Start byte offset of the contextual decision span within the turn. + /// + ///
+ /// + /// **Experimental.** This type is part of an experimental wire-protocol surface + /// and may change or be removed in future SDK or CLI releases. + /// + ///
+ pub span_start: i64, + /// Human turn containing the contextual decision. + /// + ///
+ /// + /// **Experimental.** This type is part of an experimental wire-protocol surface + /// and may change or be removed in future SDK or CLI releases. + /// + ///
+ pub turn_index: i64, +} + /// Session event "user_input.requested". User input request notification with question and optional predefined choices #[derive(Debug, Clone, Default, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] From 1c9b6aadaf10a130b0ac9cde0126c476a456096a Mon Sep 17 00:00:00 2001 From: Stephen Toub Date: Tue, 15 Sep 2026 23:53:46 -0400 Subject: [PATCH 2/2] Update image replay snapshots for CLI 1.0.85 Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .../session_config/should_accept_blob_attachments.yaml | 2 +- .../vision_disabled_then_enabled_via_setmodel.yaml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/test/snapshots/session_config/should_accept_blob_attachments.yaml b/test/snapshots/session_config/should_accept_blob_attachments.yaml index 3d2bd508ed..71c7900348 100644 --- a/test/snapshots/session_config/should_accept_blob_attachments.yaml +++ b/test/snapshots/session_config/should_accept_blob_attachments.yaml @@ -22,6 +22,6 @@ conversations: - role: user content: |- Image file at path ${workdir}/pixel.png - You've reached the maximum number of images you can view (1) so I can't provide the image for you to see. + [image] - role: assistant content: Red diff --git a/test/snapshots/session_config/vision_disabled_then_enabled_via_setmodel.yaml b/test/snapshots/session_config/vision_disabled_then_enabled_via_setmodel.yaml index 6b595d943a..a4000a80e6 100644 --- a/test/snapshots/session_config/vision_disabled_then_enabled_via_setmodel.yaml +++ b/test/snapshots/session_config/vision_disabled_then_enabled_via_setmodel.yaml @@ -168,7 +168,7 @@ conversations: - role: user content: |- Image file at path ${workdir}/test.png - You've reached the maximum number of images you can view (1) so I can't provide the image for you to see. + [image] - role: assistant content: I can see the image now! It shows a simple light blue/cyan colored square or rectangle positioned against a white background. The shape appears to be a solid colored geometric form - it's a fairly minimal image with